Cubo familiar de primavera
Sitio web oficial de aprendizaje: https://spring.io/
Capítulo 1 Marco Spring5
Documentación de Spring Framework
https://docs.spring.io/spring-framework/docs/current/reference/html/index.html
1.1 Descripción general del marco Spring
/*
1、Spring是轻量级的开源的JavaEE框架
2、Spring可以解决企业应用开发的复杂性
3、Spring有两个核心部分：IOC和AOP
（1）IOC：控制反转，把创建对象过程交给Spring进行管理
（2）AOP：面向切面，不修改源代码进行功能增强
4、Spring特点
（1）方便解耦，简化开发
（2）AOP编程支持
（3）方便程序测试
（4）方便和其他框架进行整合
（5）方便进行事务操作
（6）降低API开发难度
*/
Caso de inicio
El primer paso es descargar Spring5 y seleccionar la última versión estable: 5.3.8
https://repo.spring.io/release/org/springframework/spring/
Paso 2 Crear un proyecto java e importar paquetes JAR relacionados con Spring
Paso 3 Crear clases y métodos
Usuario.java
public class User {
public void add(){
System.out.println("add...");
}
}
El cuarto paso es crear un archivo de configuración de Spring bean1.xml y crear un objeto
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置User对象创建-->
<bean id="user" class="edu.mm.User"></bean>
</beans>
Paso 5 Prueba
@Test
public void testAdd(){
//1.加载spring配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//2.获取通过配置文件创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
}
Ejecute la captura de pantalla:
1. 2 contenedores COI
1.2.1 Concepto COI
(1) IOC, inversión de control, entregar el proceso de creación y llamada de objetos entre objetos a Spring para su gestión.
(2) El propósito de usar IOC: para reducir el grado de acoplamiento.
1.2.2 El principio subyacente de la COI
Palabras clave: análisis xml, patrón de fábrica, reflexión
Requisitos: Cree UserService.java y UserDao.java, y espere llamar a un método en la capa dao en la capa de servicio.
proceso del COI
El primer paso: crear un objeto a través del archivo de configuración xml.
<bean id="" class=""></bean>
Paso 2: crea una clase de fábrica
class UserFactory{
public static UserDao getDao(){
String classValue=class属性值;//1.xml解析(基于Dom4j），获取全类名
Class clazz=Class.forName(classValue);//2.通过反射创建对象
return (UserDao)clazz.newInstance();
}
}
Paso 3: Cree objetos en la capa de servicio a través del patrón de fábrica
class UserService{
public void excute(){
UserDao dao=UserFactory.getDao();
dao.add();
}
}
Desventajas del método original nueva palabra clave: el grado de acoplamiento es demasiado alto
UserDao.java
class UserDao{
public void add(){
...
}
}
UserService.java
class UserService{
UserDao userDao=new UserDao();
userDao.add();
}
Modo de fábrica La clase de fábrica se utiliza como middleware para reducir el acoplamiento entre la capa de servicio y la capa de dao.
UserFactory.java
class UserFactory{
public static UserDao getDao(){
return new UserDao();
}
}
UserService.java
class UserService{
public void excute(){
UserDao dao=UserFactory.getDao();
dao.add();
}
}
1.2.3 Interfaz IOC (BeanFactory)
-
La idea de IOC se basa en el contenedor IOC, y la capa inferior del contenedor IOC es la fábrica de objetos.
-
Spring proporciona dos formas de contenedor IOC (dos interfaces)
-
BeanFactory
IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用 *加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象 -
ApplicationContext
BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用 *加载配置文件时候就会把在配置文件对象进行创建
-
1.2.4 Gestión de beans de operación IOC (basada en xml)
Operación IOC La administración de beans incluye: Spring crea objetos e inyecta atributos.
Hay dos formas de operaciones de administración de Bean: xml, anotaciones
-
Crear objetos basados en xml
<bean id="user" class="edu.mm.User"></bean>【Aviso】
(1) En el archivo de configuración de Spring, use la etiqueta de bean y agregue los atributos correspondientes en la etiqueta para realizar la creación de objetos
(2) Hay muchos atributos en la etiqueta del bean, y los atributos comúnmente usados son los siguientes
atributo id: identificador único
atributo de clase: ruta completa de clase (ruta de clase del paquete)
(3) Al crear un objeto, el valor predeterminado es ejecutar el método de construcción sin parámetros para completar la creación del objeto.
-
Inyectar atributos basados en xml
/*DI：依赖注入，就是注入属性*/-
Inyección usando el método establecido
Paso 1: Cree una clase de entidad, defina los atributos y los métodos de conjunto correspondientes
public class User { public String name; public String stumum; public void setName(String name) { this.name = name; } public void setStumum(String stumum) { this.stumum = stumum; } }Paso 2: Cree un objeto en el archivo de configuración de Spring e inyecte propiedades
<!--使用property属性注入 name：类里面属性名称 value：向属性注入的值--> <bean id="user" class="edu.mm.User"> <property name="name" value="java"></property> <property name="stumum" value="171404050119"></property> </bean> -
Inyección usando un constructor parametrizado
Paso 1: crear clases, atributos y constructores con parámetros
public class Book { public String bName; public String author; public Book(String bName, String author) { this.bName = bName; this.author = author; } }Paso 2: Configurar en el archivo de configuración de Spring
<bean id="book" class="edu.mm.Book"> <constructor-arg name="author" value="屈原"></constructor-arg> <constructor-arg name="bName" value="楚辞"></constructor-arg> </bean>Paso tres: prueba
@Test public void testBook(){ //1.加载spring配置文件 ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml"); //2.获取通过配置文件创建的对象 Book book = context.getBean("book", Book.class); System.out.println(book.bName); }
-
-
Inyectar otros tipos de atributos basados en xml
-
Propiedad de inyección - frijol externo
/* （1）创建两个类service类和dao类 （2）在service调用dao里面的方法 （3）在spring配置文件中进行配置 */ public class UserService { public UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void show(){ userDao.showInfo(); System.out.println("I am service"); } }<!--注入userDao对象 name属性：类里面属性名称 ref属性:创建userDao对象bean标签id值--> <bean id="userService" class="edu.mm.service.UserService"> <property name="userDao" ref="userDao"></property> </bean> <bean id="userDao" class="edu.mm.dao.UserDao"></bean> -
Propiedad de inyección - frijol interno
/* 一对多关系：部门和员工 在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示 */ public class Dept { public String dName; public void setdName(String dName) { this.dName = dName; } } public class Emp { public String empName; public String empGender; public Dept dept;//员工属于某一个部门，使用对象形式表示 public void setEmpName(String empName) { this.empName = empName; } public void setEmpGender(String empGender) { this.empGender = empGender; } public void setDept(Dept dept) { this.dept = dept; } }<bean id="emp" class="edu.mm.bean.Emp"> <property name="empName" value="李白"></property> <property name="empGender" value="男"></property> <property name="dept"> <bean id="dept" class="edu.mm.bean.Dept"> <property name="dName" value="保卫科"></property> </bean> </property> </bean> -
Inyectar propiedades: asignaciones en cascada
método uno:
<bean id="emp" class="edu.mm.bean.Emp"> <!--设置两个普通属性--> <property name="empName" value="李白"></property> <property name="empGende" value="男"></property> <!--级联赋值--> <property name="dept" ref="dept"></property> </bean> <bean id="dept" class="edu.mm.bean.Dept"> <property name="dName" value="保卫科"></property> </bean>Método 2:
<!--前提：Emp实体类要有getDept()--> <bean id="emp" class="edu.mm.dao.Emp"> <property name="empName" value="李白"></property> <property name="empGender" value="男"></property> <property name="dept" ref="dept"></property> <property name="dept.dName" value="保卫科"></property> </bean> <bean id="dept" class="edu.mm.dao.Dept"></bean> -
Inyectar atributos: atributos de colección
1. Inyectar atributos de tipo matriz
2. Inyecte la propiedad de tipo de colección List
3. Listar las propiedades del objeto de inyección de colección
4. Inyecte el atributo de tipo de colección de mapas
5. Inyecte el atributo Establecer tipo de colección
public class Stu { //1 数组类型属性 private String[] courses; //2 List集合类型属性 private List<String> list; //3 List集合注入对象属性 private List<Course> courseList; //4 Map 集合类型属性 private Map<String,String> maps; //5 Set 集合类型属性 private Set<String> sets; public void setSets(Set<String> sets) { this.sets = sets; } public void setCourses(String[] courses) { this.courses = courses; } public void setList(List<String> list) { this.list = list; } public void courseList(List<Course> courseList) { this.courseList = courseList; } public void setMaps(Map<String, String> maps) { this.maps = maps; } }<!--集合类型属性注入--> <bean id="stu" class="edu.mm.bean.Stu"> <!--1.数组类型属性注入--> <property name="courses"> <array> <value>java 课程</value> <value>数据库课程</value> </array> </property> <!--2.list类型属性注入--> <property name="list"> <list> <value>张三</value> <value>小三</value> </list> </property> <!--3.List集合中注入对象属性--> <property name="courseList"> <list> <ref bean="course1"></ref> <ref bean="course2"></ref> </list> </property> <!--4.map类型属性注入--> <property name="maps"> <map> <entry key="JAVA" value="java"></entry> <entry key="PHP" value="php"></entry> </map> </property> <!--5.set类型属性注入--> <property name="sets"> <set> <value>MySQL</value> <value>Redis</value> </set> </property> </bean> <bean id="course1" class="edu.mm.bean.Course"> <property name="cname" value="Spring5 框架"></property> </bean> <bean id="course2" class="edu.mm.bean.Course"> <property name="cname" value="MyBatis 框架"></property> </bean>
-
-
FactoryBean
1. Spring tiene dos tipos de frijoles, uno común y otro de fábrica (FactoryBean)
2. Bean ordinario: el tipo de bean definido en el archivo de configuración es el tipo de retorno
3. Bean de fábrica: el tipo de bean definido en el archivo de configuración puede ser diferente del tipo de retorno
El primer paso es crear una clase, dejar que esta clase sea un bean de fábrica e implementar la interfaz FactoryBean
El segundo paso es implementar el método en la interfaz y definir el tipo de bean devuelto en el método implementado.
-
Gestión de beans de operación de IOC (alcance de beans)
/* 在Spring中，默认情况下，bean 是单实例对象 （1）在spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例 （2）scope 属性值 第一个值 默认值，singleton，表示是单实例对象 第二个值 prototype，表示是多实例对象 （3）singleton 和 prototype 区别 第一，singleton单实例，prototype多实例 第二，scope=singleton，加载spring配置文件时创建单实例对象 scope=prototype，在调用getBean方法时创建多实例对象 */ -
IOC Operation Bean Management (ciclo de vida del frijol)
/*bean 生命周期: （1）通过构造器创建 bean 实例（无参数构造） （2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法） （3）调用 bean 的初始化的方法（需要进行配置初始化的方法） （4）使用bean（对象获取到了） （5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法） */ -
Gestión de bean de operación IOC (xml autowiring)
De acuerdo con las reglas de ensamblaje especificadas (nombre de propiedad o tipo de propiedad), Spring inyecta automáticamente el valor de propiedad coincidente
<!--实现自动装配 bean标签属性 autowire，配置自动装配 autowire 属性常用两个值： byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样 byType 根据属性类型注入 -->
1.2.5 Gestión de beans de operación IOC (basada en anotaciones)
-
El significado de la anotación.
(1) La anotación es una marca de código especial, formato: @nombre de anotación (nombre de atributo=valor de atributo, nombre de atributo=valor de atributo...)
(2) Usar anotaciones, que actúan sobre clases, métodos y atributos
(3) Propósito de usar anotaciones: simplificar la configuración xml
-
Spring proporciona las siguientes anotaciones para la creación de objetos en la gestión de Bean
(1) @Componente
（2）@Servicio
(3) @Controlador
（4）@Repositorio
Las funciones de las cuatro anotaciones anteriores son las mismas y todas se pueden usar para crear instancias de beans
-
Creación de objetos basada en anotaciones
-
Paso 1: Introduce la dependencia spring-aop-5.3.8.jar
-
Paso 2: Active el escaneo de componentes
<!--开启组件扫描 1、如果扫描多个包，多个包使用逗号隔开 ;2、扫描包上层目录--> <context:component-scan base-package="edu.mm"></context:component-scan> -
Paso 3: Cree una clase y agregue anotaciones de creación de objetos en la clase
/*在注解里面value属性值可以省略不写，默认值是类名称，首字母小写*/
-
-
Inyección de propiedades basada en anotaciones
-
@Autowired: Autowire basado en el tipo de atributo
-
@Resource: de forma predeterminada, se puede inyectar por tipo o se puede inyectar por nombre
-
@Value: Inyectar propiedades de tipo normal
-
@Qualifier: inyectar por nombre
Utilice @Qualifier con @Autowired
-
-
Desarrollo completamente anotado
Paso 1: Cree una clase de configuración para reemplazar el archivo de configuración xml
@Configuration @ComponentScan(basePackages = "edu.mm") public class SpringConfig { .... }Paso 2: escribir la clase de prueba
@Test public void testService2() { //加载配置类 ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class); UserService userService = context.getBean("userService",UserService.class); System.out.println(userService); userService.add(); }
1.3 POA
1.3.1 concepto POA
Programación orientada a aspectos (aspecto), el uso de AOP puede aislar cada parte de la lógica comercial, de modo que se reduce el acoplamiento entre las partes de la lógica comercial, se mejora la reutilización del programa y se mejora la eficiencia del desarrollo. En definitiva, se trata de añadir nuevas funciones a las funciones principales sin modificar el código fuente.
1.3.2 El principio subyacente de AOP
La capa subyacente de AOP se implementa mediante proxies dinámicos, incluidos: proxies dinámicos JDK y proxies dinámicos CGLIB.
- Proxy dinámico JDK - con interfaz
/*创建接口实现类代理对象，增强类的方法*/
-
Proxy dinámico CGLIB: sin interfaz
/*创建子类的代理对象，增强类的方法*/
1.4 Plantilla Jdbc
Spring Framework encapsula JDBC y usa JdbcTemplate para facilitar las operaciones de la base de datos.
paso:
Paso 1 : Preparativos
(1) Introducir paquetes jar relacionados
-
druida-1.1.9.jar
-
mysql-conector-java-5.1.7-bin.jar
-
primavera-jdbc-5.3.8.jar
-
spring-orm-5.3.8.jar
-
primavera-tx-5.3.8.jar
(2) Crear una base de datos
/*
Navicat MySQL Data Transfer
Source Server : hh
Source Server Version : 80023
Source Host : localhost:3306
Source Database : school
Target Server Type : MYSQL
Target Server Version : 80023
File Encoding : 65001
Date: 2021-07-05 11:59:40
*/
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for student
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
`sno` char(10) NOT NULL,
`sname` char(20) DEFAULT NULL,
`ssex` char(2) DEFAULT NULL,
`sage` smallint DEFAULT NULL,
`sdept` char(20) DEFAULT NULL,
PRIMARY KEY (`sno`),
UNIQUE KEY `sname` (`sname`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-- ----------------------------
-- Records of student
-- ----------------------------
INSERT INTO `student` VALUES ('100256', '刘晨', '男', '19', 'IS');
INSERT INTO `student` VALUES ('1114', '马修', '男', '20', 'CS');
INSERT INTO `student` VALUES ('171145', '屈明明', '男', '15', 'CS');
INSERT INTO `student` VALUES ('1714', '李白', '男', '100', '九三学社');
INSERT INTO `student` VALUES ('178963', '张力', '女', '18', 'MA');
(3) Configure el grupo de conexiones de la base de datos en el archivo de configuración de Spring
Método 1: configurar directamente el grupo de conexiones de la base de datos
<!--组件扫描-->
<context:component-scan base-package="edu.mm"></context:component-scan>
<!--配置数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="url" value="jdbc:mysql:///school?useUnicode=true&characterEncoding=utf8"></property>
<property name="username" value="root"></property>
<property name="password" value="123456"></property>
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
</bean>
Método 2: spring.xml lee el archivo dbConfig.properties para configurar el grupo de conexiones de la base de datos
dbConfig.properties
jdbc.user=root
jdbc.password=123456
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/school?useUnicode=true&characterEncoding=utf8
jdbc.driverClass=com.mysql.jdbc.Driver
resorte.xml
<!--引入外部配置文件-->
<context:property-placeholder location="classpath:dbConfig.properties"> </context:property-placeholder>
<!--组件扫描-->
<context:component-scan base-package="edu.mm"></context:component-scan>
<!--配置数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="url" value="${jdbc.jdbcUrl}"></property>
<property name="username" value="${jdbc.user}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="driverClassName" value="${jdbc.driverClass}"></property>
</bean>
(4) Configure el objeto JdbcTemplate e inyecte DataSource
<!--创建JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--注入dataSource-->
<property name="dataSource" ref="dataSource"></property>
</bean>
Paso 2 : escribir código y usar JdbcTemplate para operar la base de datos
Llame a update (), queryForObject () en el objeto JdbcTemplate para realizar la operación de agregar, eliminar, modificar y verificar
Tome la inserción de una pieza de datos como un ejemplo:
@Test
public void test1(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
//1.创建sql语句
String sql="insert into student values(?,?,?,?,?)";
Student student=new Student();
student.setSno("1714");
student.setSname("李白");
student.setSage(100);
student.setSsex("男");
student.setSdept("九三学社");
//2.调用方法实现
Object[] args={
student.getSno(),student.getSname(),student.getSsex(),student.getSage(),student.getSdept()};
int ret = jdbcTemplate.update(sql, args);
System.out.println(ret);
}
Reponer:
/*
param1:sql语句
param2:可变参数，sql语句的值
*/
int update(String sql, @Nullable Object... args);
/*添加一条数据*/
String sql = "insert into t_book values(?,?,?)";
Object[] args = {
book.getUserId(), book.getUsername(), book.getUstatus()};
/*修改一条数据*/
String sql = "update t_book set username=?,ustatus=? where user_id=?";
Object[] args = {
book.getUsername(), book.getUstatus(),book.getUserId()};
/* 删除一条数据*/
String sql = "delete from t_book where user_id=?";
/*
param1:sql语句
param:返回类型Class
*/
String sql = "select count(*) from t_book";//查询表的记录数
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);//查询返回某个值
/*
param1:sql 语句
param2:RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
param3:sql语句值
*/
String sql = "select * from t_book where user_id=?";//查询返回对象
Book book = jdbcTemplate.queryForObject(sql, new
BeanPropertyRowMapper<Book>(Book.class), id);//查询返回对象
/*
param1:sql 语句
param2:RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
*/
String sql = "select * from t_book";//查询返回集合
List<Book> bookList = jdbcTemplate.query(sql, new
BeanPropertyRowMapper<Book>(Book.class));//查询返回集合
Paso 3: resuelva el error
Cuando use la inyección automática @Autowired en la clase de prueba, se informará el error anterior
Solución: agregue @RunWith(SpringRunner.class)anotaciones sobre la clase de prueba
Motivo: con @RunWith(SpringRunner.class), estas clases se pueden instanciar en el contenedor de primavera y la inyección automática puede tener efecto; de lo contrario, se produce una NullPointerExecption
1.5 Gestión de transacciones
Una transacción es la unidad más básica de las operaciones de la base de datos.Lógicamente, un conjunto de operaciones tiene éxito o todas las operaciones fallan si una falla.
Al realizar la gestión de transacciones en Spring, use la gestión de transacciones declarativas, el método más utilizado se basa en anotaciones, use la anotación @Transactiona para agregar elementos a la capa de servicio, la capa inferior se basa en AOP y use la interfaz PlatformTransactionManager para la gestión de transacciones .
Cuatro características de las cosas: atomicidad, consistencia, aislamiento y persistencia.
Escenario típico: transferencia bancaria
1.6 Nuevas características de Spring5
(1) Marco de registro integrado
(2) anotación @Nullable
(3) Objeto de registro funcional
(4) Integrar el marco de prueba de unidad JUnit5
(5) Uso de Spring Webflux