Índice
Noções básicas de acesso a dados do Spring Boot
Etapa 1: criar um novo projeto Maven e adicionar dependências
Etapa 2: configurar a fonte de dados - torná-la acessível ao programa
Etapa 3: configurar a fonte de dados - tornar o IDEA acessível
Etapa 4: adicionar banco de dados e tabelas
Etapa 5: Estabeleça a estrutura de cada nível e escreva o código correspondente
Etapa 6: testar cada método de interface
Noções básicas de acesso a dados do Spring Boot
dados de primavera
O projeto Spring Data é um subprojeto do Spring. O objetivo é simplificar a construção de contagens de acesso a dados com base em aplicativos de framework spring, incluindo bancos de dados não relacionais, frameworks Map-Reduce, serviços de dados em nuvem, etc.; também inclui suporte de acesso para bancos de dados relacionais.
Spring Data é uma estrutura de código aberto para simplificar o acesso ao banco de dados e oferecer suporte a serviços em nuvem. Seu principal objetivo é tornar o acesso ao banco de dados conveniente e rápido, e oferece suporte a estrutura de redução de mapa e serviços de dados de computação em nuvem. Além disso, também oferece suporte a serviços de dados baseados em bancos de dados relacionais, como o Oracle RAC. Para projetos com dados massivos, o Spring Data pode ser usado para simplificar o desenvolvimento do projeto, assim como o suporte do Spring Framework para JDBCORM, o Spring Data tornará o acesso aos dados mais conveniente.
ORM
Mapeamento objeto-relacional (ORM para abreviar), o método de desenvolvimento orientado a objeto é o método de desenvolvimento dominante no ambiente de desenvolvimento de aplicativos de nível empresarial atual, e o banco de dados relacional é o sistema de armazenamento de dados principal para armazenamento permanente de dados no aplicativo de nível empresarial ambiente. Objetos e dados relacionais são duas manifestações de entidades de negócios.As entidades de negócios são representadas como objetos na memória e como dados relacionais no banco de dados. Existem associações e relacionamentos de herança entre objetos na memória, mas em um banco de dados, os dados relacionais não podem expressar diretamente associações muitos-para-muitos e relacionamentos de herança. Portanto, o sistema de mapeamento objeto-relacional (ORM) geralmente existe na forma de middleware e realiza principalmente o mapeamento de objetos de programa para dados de banco de dados relacional.
Estrutura ORM e suas vantagens e desvantagens
JDBC
idbc (Java DataBase Connectivitv) é a interface nativa para iava se conectar a operações de banco de dados. JDBC é um APL para programadores Java e um modelo de interface para provedores de serviços que implementam conexões com bancos de dados. Como uma API, JDB fornece uma interface padrão para desenvolvimento de programas e fornece um método padrão para vários fornecedores de banco de dados e fornecedores de middleware terceirizados para realizar a conexão com o banco de dados. Resumo de uma frase: o jdbc é obrigatório para todos os frameworks operarem bancos de dados, fornecidos pelos fabricantes de banco de dados, mas para facilitar que os programadores Java chamem vários bancos de dados, cada fabricante de banco de dados deve implementar a interface idbc.
Em nossas dependências de inicialização do Spring, o uso de JDBC seleciona JDBCAPI.
Spring-data-jdbc não é um jdbc comum. Ele possui alguns recursos semelhantes ao jpa, como a capacidade de deduzir sql com base no nome do método, CRUD básico etc., e também possui a capacidade de escrever sql nativo. O mais importante é que é bem refrescante e não precisa depender de hibernte ou jpa.
JPA
jpa (Java Persistence API) é uma especificação de persistência java e o padrão do framework orm, que é implementado pelos frameworks rm convencionais. A Sun introduziu a nova especificação JPAORM por dois motivos: primeiro, para simplificar o trabalho de desenvolvimento de aplicativos Java EE e Java SE existente; segundo, a Sun espera integrar a tecnologia ORM para realizar a unidade do mundo. ORM é uma ideia, que é uma camada intermediária inserida entre o programa aplicativo e a API do JDBC. O JDBC não suporta muito bem a programação orientada a objetos. O ORM resolve esse problema e mapeia campos para objetos com eficiência por meio do JDBC . As implementações específicas incluem hibernate, spring data jpa open jpa.
Spring DataJPA pode ser entendido como o reencapsulamento e abstração da especificação JPA, e a camada inferior ainda é implementada usando a tecnologia JPA do Hibernate
Implementação simples de JDBC
Na inicialização do Spring, obtemos a conexão do banco de dados por meio da fonte de dados e podemos usar instruções JDBC nativas para operar o banco de dados. O próprio Spring também cria um pacote leve para JDBC nativo, chamado dbcTemplate. Após configurar as dependências do DBC, o Spring boot configura o JdbcTemplat e o coloca no container, sendo que os próprios programadores só precisam injetá-lo para utilizá-lo. Abaixo está um exemplo simples de CRUD.
Etapa 1: criar um novo projeto Maven e adicionar dependências
Etapa 2: configurar a fonte de dados - torná-la acessível ao programa
Nota: Depois de criar o projeto, você precisa configurar seu próprio armazém local. Meu artigo anterior falou sobre como configurá-lo
Aguarde a conclusão do download da dependência e escreva as seguintes informações de configuração. Incluindo driver, endereço da fonte de dados, nome de usuário e senha de acesso à fonte de dados
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/testdb?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456Etapa 3: configurar a fonte de dados - tornar o IDEA acessível
Conforme mostrado na figura, clique nos bancos de dados ou no banco de dados à direita para abrir o menu de imagem
Depois de baixar o driver, o link de teste foi bem-sucedido. Clique em OK para confirmar
Etapa 4: adicionar banco de dados e tabelas
Os códigos são data.sql, Schema.sql, user.sql
INSERT INTO `article` VALUES ('1','2101','SpringBoot 核心注解',
'核心注解的主要作用','00000008976','2023-01-16 12:11:12','2023-01-16 12:19:19');
INSERT INTO `article` VALUES ('2','356752','JVM 调优',
'HotSpot 虚拟机详解','00000000026','2023-06-16 12:15:27','2023-06-16 18:15:30');
INSERT INTO `article` VALUES ('3','454','JVM核心思想',
'编程的各种难题','0000000008','2023-08-5 12:15:27','2023-08-5 19:15:30');DROP DATABASE IF EXISTS `Blog`;
create database Blog;
Use Blog;
DROP TABLE IF EXISTS `article`;
CREATE TABLE `article`
(
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`user_id` int(11) NOT NULL COMMENT '作者 ID',
`title` varchar(100) NOT NULL COMMENT '文章标题',
`summary` varchar(200) DEFAULT NULL COMMENT '文章概要',
`read_count` int(11) unsigned zerofill NOT NULL COMMENT '阅读读数',
`create_time` datetime NOT NULL COMMENT '创建时间',
`update_time` datetime NOT NULL COMMENT '最后修改时间',
PRIMARY KEY (`id`)
) ENGINE = InnoDB
AUTO_INCREMENT = 1
DEFAULT CHARSET = utf8mb4;DROP DATABASE IF EXISTS `testdb`;
create database testdb;
Use testdb;
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`user_id` int NOT NULL AUTO_INCREMENT COMMENT '用户 ID',
`user_name` varchar(255) DEFAULT NULL COMMENT '用户名',
`status` varchar(255) DEFAULT NULL COMMENT '用户状态',
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;Após adicionar, clique no botão triângulo no canto superior esquerdo do usuário para criar uma tabela de biblioteca (as outras duas instruções sql podem ser entretidas sozinhas, que não serão utilizadas neste artigo)
Etapa 5: Estabeleça a estrutura de cada nível e escreva o código correspondente
Após a construção do banco de dados e das tabelas, precisamos criar pacotes de software em todos os níveis, que armazenem diferentes códigos para deixar o projeto mais bonito e utilizável. O framework e o código são os seguintes:
Os códigos de cada arquivo são os seguintes, e o nome do arquivo está no comentário, basta copiar e colar
//useDao
public interface UserDao {
int addUser(User user);
int update(User user);
int delete(User user);
int count(User user);
List<User> getList(User user);
User getUser(User user);
void batchAddUser(List<Object[]> batchArgs);
}
//UserDaoimpl
@Repository
public class UserDaoimpl implements UserDao {
@Resource
private JdbcTemplate jdbcTemplate;
@Resource
private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
@Override
public int addUser(User user) {
String sql = "INSERT into `user` (`user`.user_name,`user`.`status`) VALUES(?,?);";
return jdbcTemplate.update(sql, user.getUserName(), user.getStatus());
}
@Override
public int update(User user) {
String sql = "UPDATE `user` SET status=? WHERE user_name=?;";
return jdbcTemplate.update(sql, user.getStatus(), user.getUserName());
}
@Override
public int delete(User user) {
String sql = "DELETE FROM `user` where user_name=?;";
return jdbcTemplate.update(sql, user.getUserName());
}
@Override
public int count(User user) {
String sql = "SELECT COUNT(*) FROM `user` where `status`=?;";
return jdbcTemplate.queryForObject(sql, Integer.class, user.getStatus());
}
@Override
public List<User> getList(User user) {
String sql = "SELECT * FROM `user` where `status`=?;";
return jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class), user.getStatus());
}
@Override
public User getUser(User user) {
String sql = "SELECT * FROM `user` where `user_id`=?;";
return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), user.getStatus());
}
@Override
public void batchAddUser(List<Object[]> batchArgs) {
String sql = "INSERT into `user` (`user`.user_name,`user`.`status`) VALUES(?,?);";
jdbcTemplate.batchUpdate(sql,batchArgs);
}
}
//User
@Data
@AllArgsConstructor
@ToString
@NoArgsConstructor
public class User {
private Integer userId;
private String userName;
private String status;
}
//UserService
public interface UserService {
public int addUser(User user);
public int updateUser(User user);
public int deleteUser(User user);
public int countUser(User user);
public List<User> getList(User user);
public User getUser(User user);
public void batchAddUser(List<Object[]> batchArgs);
}
//UserServiceimp
@Service("userService")
public class UserServiceimp implements UserService {
@Resource
private UserDao userDao;
@Override
public int addUser(User user){
return userDao.addUser(user);
}
@Override
public int updateUser(User user){
return userDao.update(user);
}
@Override
public int deleteUser(User user) {
return userDao.delete(user);
}
@Override
public int countUser(User user) {
return userDao.count(user);
}
@Override
public List<User> getList(User user) {
return userDao.getList(user);
}
@Override
public User getUser(User user) {
return userDao.getUser(user);
}
@Override
public void batchAddUser(List<Object[]> batchArgs) {
userDao.batchAddUser(batchArgs);
}
}Etapa 6: testar cada método de interface
Criamos um método de teste na classe de teste de test e podemos testar a interface que escrevemos. Observe que você precisa testar frase por frase, caso contrário, cometerá erros. Escrevi comentários para o código de teste
@Resource
private JdbcTemplate jdbcTemplate;
@Autowired
UserService userService;
@Test
void taa(){
User user=new User();
user.setUserName("阿三");
user.setStatus("在线");
// 新增用户
int i = userService.addUser(user);
System.out.println("新增用户成功");
// 修改用户
// User user1 =new User();
// user1.setUserName("乌鸦哥");
// user1.setStatus("在线");
// int u = userService.updateUser(user1);
// System.out.println("修改用户成功");
//批量添加
// List<Object[]> batchArgs = new ArrayList<>();
// Object[] a1 = {"}
// Object[] a2 = {"b","在线"};
// Object[] a3 = {"c","在线"};
// Object[] a4 = {"d","在线"};
// batchArgs.add(a1);
// batchArgs.add(a2);
// batchArgs.add(a3);
// batchArgs.add(a4);
// userService.batchAddUser(batchArgs);
// System.out.println("批量增加完毕");
//查询在线用户数量
// User user2 = new User();
// user2.setStatus("在线");
// int a = userService.countUser(user2);
// System.out.println("在线用户个数为： "+ a);
//获取用户列表(user2在线)
// List<User> userList = userService.getList(user2);
// System.out.println("在线用户列表查询成功");
//遍历在线列表
// for (User user3 : userList){
// System.out.println("用户ID："+ user3.getUserId() +",用户名："+
// user3.getUserName() + " ，状态："+ user3.getStatus()
// );
// }
}Resumir
O conteúdo acima é o de hoje. Este artigo fala principalmente sobre o conhecimento básico de acesso a dados no Spring Boot e como usar o JDBC para acesso simples a dados. A configuração automática e o desenvolvimento simplificado do Spring Boot melhoraram muito a eficiência do desenvolvimento e espero que todos possam ganhar algo. Se houver algo inapropriado neste artigo, curta e encaminhe-o na área de comentários ~