标签：void sunxiaping org import com public Spring5
1 Spring的概念
1.1 Spring框架的概述
-
Spring是轻量级的开源的JavaEE框架。
-
Spring框架可以解决企业应用开发的复杂性。
-
Spring框架有两个核心部分：IOC和AOP。
- IOC：控制反转，把创建对象的过程交给Spring进行管理。
- AOP：面向切面，在不修改源代码的情况下进行功能的增强。
-
Spring框架的特点：
- 方便解耦，简化开发。
- AOP编程的支持。
- 方便程序的测试。
- 方便集成各种优秀框架。
- 降低JavaEE API的使用难度。
- 声明式事务的支持。
- Spring框架是Java源码学习的经典范例。
1.2 Spring框架的入门案例
1.2.1 导入Spring5相关jar包的Maven坐标
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
1.2.2 创建普通类
- User.java
package com.sunxiaping;
public class User {
public void add(){
System.out.println("add......");
}
}
1.2.3 创建Spring的配置文件，在配置文件中配置要创建的对象
- applicationContext.xml
<?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">
<bean id="user" class="com.sunxiaping.User"></bean>
</beans>
1.2.4 测试
- 示例：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserTest {
public static void main(String[] args) {
//加载配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取配置创建的对象
User user = context.getBean("user", User.class);
user.add();
}
}
2 IOC容器
2.1 概念和原理
2.1.1 什么是IOC？
- IOC(控制反转)，把对象的创建和对象之间调用的过程，交给Spring进行管理。
- 使用IOC的目的：为了降低耦合度。
2.1.2 IOC的底层原理
- xml解析、工厂设计模式、反射。
2.2 IOC接口（BeanFactory）
-
IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。
-
Spring提供IOC容器实现的两种方式：
-
BeanFactory：
- IOC容器最基本的实现方式，是Spring内部的使用接口，不提供开发人员进行使用。
- 加载配置文件的时候不会去创建对象，而是在获取对象（或使用对象）的时候才去创建对象。
-
ApplicationContext：
- BeanFactory接口的子接口，提供更多更强大的功能，一般是由开发人员进行使用的。
- 加载配置的文件的时候就会立即创建对象。
- ApplicationContext接口的实现类。
-
2.3 IOC操作Bean管理
2.3.1 什么是Bean管理？
- Bean管理指的是如下的两个操作：
- Spring创建对象。
- Spring注入属性。
2.3.2 Bean管理的操作有两种实现方法
- 基于XML配置文件方式实现。
- 基于注解方式实现。
2.3.3 基于XML方式进行Bean管理的操作
2.3.3.1 基于XML方式创建对象
- 示例：applicationContext.xml
<?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">
<!--
在Spring配置文件中，使用bean标签，标签中添加对应的属性即可，就可以实现对象的创建。
在Bean标签中有很多属性，如下是一些常用的属性：
- id属性：唯一标识。
- class属性：类的全路径。
创建对象的时候，默认是调用的是无参构造方法。
-->
<bean id="user" class="com.sunxiaping.User"></bean>
</beans>
2.2.3.2 基于XML方式注入属性
- DI：依赖注入，就是注入属性。
2.2.3.2.1 创建对象和使用Setter方法进行注入
- 示例：通过Setter方法进行注入
- Book.java
package com.sunxiaping;
public class Book {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
- applicationContext.xml
<?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">
<bean id="book" class="com.sunxiaping.Book">
<!--
使用property完成属性注入
name：类里面属性名称
value：向属性中注入的值
-->
<property name="name" value="红楼梦"/>
</bean>
</beans>
- 测试
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Book book = context.getBean("book", Book.class);
System.out.println("book.getName() = " + book.getName());
}
}
2.2.3.2.2 有参构造注入属性
- 示例：使用有参构造方法进行注入
- Book.java
package com.sunxiaping;
public class Book {
private String name;
public Book(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
- applicationContext.xml
<?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">
<bean id="book" class="com.sunxiaping.Book" >
<constructor-arg name="name" value="西游记"/>
</bean>
</beans>
- 测试
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Book book = context.getBean("book", Book.class);
System.out.println("book.getName() = " + book.getName());
}
}
2.2.3.2.3 p名称空间注入
- 示例：p名称空间注入，可以简化Setter方法注入
- Book.java
package com.sunxiaping;
public class Book {
private String name;
private Double price;
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="book" class="com.sunxiaping.Book" p:name="红楼梦" p:price="20">
</bean>
</beans>
- 测试
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Book book = context.getBean("book", Book.class);
System.out.println("book = " + book);
}
}
2.2.3.2.4 注入null和特殊字符
- 示例：注入null和特殊字符
- Book.java
package com.sunxiaping;
public class Book {
private String name;
private Double price;
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", price=" + price +
", address='" + address + '\'' +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="book" class="com.sunxiaping.Book">
<!--
null值
-->
<property name="name">
<null></null>
</property>
<!-- 属性值包含特殊字符 -->
<property name="address">
<value><![CDATA[<<江苏>>]]]></value>
</property>
</bean>
</beans>
- 测试
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Book book = context.getBean("book", Book.class);
System.out.println("book = " + book);
}
}
2.2.3.2.5 注入属性-外部Bean
- 示例：注入属性-外部Bean
- UserDao.java
package com.sunxiaping.dao;
public interface UserDao {
public void update();
}
- UserDaoImpl.java
package com.sunxiaping.dao.impl;
import com.sunxiaping.dao.UserDao;
public class UserDaoImpl implements UserDao {
@Override
public void update() {
System.out.println("dao update....");
}
}
- UserService.java
package com.sunxiaping.service;
import com.sunxiaping.dao.UserDao;
public class UserService {
private UserDao userDao;
public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void update(){
System.out.println("service update...");
userDao.update();
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userDao" class="com.sunxiaping.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="com.sunxiaping.service.UserService">
<property name="userDao" ref="userDao"></property>
</bean>
</beans>
- 测试
package com.sunxiaping;
import com.sunxiaping.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserServiceTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.update();
}
}
2.2.3.2.6 注入属性-内部Bean
- 示例：注入属性-内部Bean（以部门和员工为例）
- Dept.java
package com.sunxiaping;
import java.io.Serializable;
/**
* 部门
*/
public class Dept implements Serializable {
/**
* 部门名称
*/
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dept{" +
"name='" + name + '\'' +
'}';
}
}
- Employee.java
package com.sunxiaping;
import java.io.Serializable;
/**
* 员工
*/
public class Employee implements Serializable {
/**
* 姓名
*/
private String name;
/**
* 性别
*/
private String gender;
/**
* 一个员工属于一个部门
*/
private Dept dept;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", gender='" + gender + '\'' +
", dept=" + dept +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="emp" class="com.sunxiaping.Employee">
<property name="name" value="张三"/>
<property name="gender" value="男"/>
<!--
设置内部Bean
-->
<property name="dept">
<bean id="dept" class="com.sunxiaping.Dept">
<property name="name" value="开发部"/>
</bean>
</property>
</bean>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class EmployeeTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Employee employee = context.getBean("emp", Employee.class);
System.out.println("employee = " + employee);
}
}
2.2.3.2.7 注入属性-级联赋值
- 示例：注入属性-级联赋值
- Dept.java
package com.sunxiaping;
import java.io.Serializable;
/**
* 部门
*/
public class Dept implements Serializable {
/**
* 部门名称
*/
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dept{" +
"name='" + name + '\'' +
'}';
}
}
- Employee.java
package com.sunxiaping;
import java.io.Serializable;
/**
* 员工
*/
public class Employee implements Serializable {
/**
* 姓名
*/
private String name;
/**
* 性别
*/
private String gender;
/**
* 一个员工属于一个部门
*/
private Dept dept = new Dept();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", gender='" + gender + '\'' +
", dept=" + dept +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="emp" class="com.sunxiaping.Employee">
<property name="name" value="张三"/>
<property name="gender" value="男"/>
<property name="dept.name" value="测试部"/>
</bean>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class EmployeeTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Employee employee = context.getBean("emp", Employee.class);
System.out.println("employee = " + employee);
}
}
2.2.3.2.8 注入集合类型属性
-
示例：注入数组类型属性、注入List类型属性、注入Set类型属性、注入Map类型属性
-
Student.java
package com.sunxiaping;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Student {
private String[] courses;
private List<String> list;
private Map<String, String> map;
private Set<String> set;
public String[] getCourses() {
return courses;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public Set<String> getSet() {
return set;
}
public void setSet(Set<String> set) {
this.set = set;
}
@Override
public String toString() {
return "Student{" +
"courses=" + Arrays.toString(courses) +
", list=" + list +
", map=" + map +
", set=" + set +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="student" class="com.sunxiaping.Student">
<property name="courses">
<array>
<value>Java课程</value>
<value>Linux课程</value>
<value>前端课程</value>
</array>
</property>
<property name="list">
<list>
<value>list1</value>
<value>list2</value>
<value>list3</value>
</list>
</property>
<property name="set">
<set>
<value>set1</value>
<value>set2</value>
<value>set3</value>
</set>
</property>
<property name="map">
<map>
<entry key="map-key1" value="map-value1"/>
<entry key="map-key2" value="map-value2"/>
<entry key="map-key2" value="map-value2"/>
</map>
</property>
</bean>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class StudentTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = context.getBean("student", Student.class);
System.out.println("student = " + student);
}
}
2.2.3.2.9 注入集合对象类型
- 示例：注入集合对象类型
- Course.java
package com.sunxiaping;
public class Course {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Course{" +
"name='" + name + '\'' +
'}';
}
}
- Student.java
package com.sunxiaping;
import java.util.List;
public class Student {
private List<Course> courseList ;
public List<Course> getCourseList() {
return courseList;
}
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
@Override
public String toString() {
return "Student{" +
"courseList=" + courseList +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="student" class="com.sunxiaping.Student">
<property name="courseList">
<list>
<ref bean="java"></ref>
<ref bean="php"></ref>
</list>
</property>
</bean>
<bean id="java" class="com.sunxiaping.Course">
<property name="name" value="java"/>
</bean>
<bean id="php" class="com.sunxiaping.Course">
<property name="name" value="php"/>
</bean>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class StudentTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = context.getBean("student", Student.class);
System.out.println("student = " + student);
}
}
2.2.3.2.10 工厂Bean
-
工厂Bean的步骤：
-
①创建类，让这个类作为工厂Bean，实现接口FactoryBean。
-
②实现接口里面的方法，在方法的定义中定义返回的Bean类型。
-
示例：工厂Bean
-
Demo.java
package com.sunxiaping;
public class Demo {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Demo{" +
"name='" + name + '\'' +
'}';
}
}
- FactoryBeanDemo.java
package com.sunxiaping;
import org.springframework.beans.factory.FactoryBean;
public class FactoryBeanDemo implements FactoryBean<Demo> {
/**
* 定义返回Bean
*
* @return
* @throws Exception
*/
@Override
public Demo getObject() throws Exception {
Demo demo = new Demo();
demo.setName("这是一个Demo");
return demo;
}
@Override
public Class<?> getObjectType() {
return Demo.class;
}
@Override
public boolean isSingleton() {
return false;
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="demo" class="com.sunxiaping.FactoryBeanDemo"></bean>
</beans>
- 示例：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class DemoTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Demo demo = context.getBean("demo", Demo.class);
System.out.println("demo = " + demo);
}
}
2.2.3.3 Bean的作用域
-
在Spring中，可以设置创建Bean实例是单实例还是多实例。
-
在Spring中，默认情况下，Bean是单实例对象。
-
示例：单实例Bean
-
Book.java
package com.sunxiaping;
public class Book {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="book" class="com.sunxiaping.Book"></bean>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Book book = context.getBean("book", Book.class);
Book book2 = context.getBean("book", Book.class);
System.out.println(book == book2);//true
}
}
- 示例：多实例Bean
- Book.java
package com.sunxiaping;
public class Book {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
默认情况下，scope的值是singleton，表示单实例Bean。
如果scope的值是prototype，则表示多实例Bean。
-->
<bean id="book" class="com.sunxiaping.Book" scope="prototype"></bean>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Book book = context.getBean("book", Book.class);
Book book2 = context.getBean("book", Book.class);
System.out.println(book == book2);//false
}
}
singleton和prototype的区别？
①singleton是单实例，prototype是多实例。
②设置scope的值是singleton的时候，加载Spring的配置文件的时候就会创建单实例对象。设置scope的值是prototype的时候，不是在加载Spring的配置文件的时候就会对象，而是在调用getBean()方法的时候创建对象。
2.2.3.4 Bean的生命周期
-
生命周期：从对象的创建到对象的销毁的过程。
-
Bean生命周期：
- ①通过构造器创建Bean实例（默认是通过无参构造器）
- ②为Bean的属性设置值和对其他Bean的引用（调用Setter方法）
- 调用Bean的初始化的方法（需要进行配置初始化的方法）。
- ④使用Bean对象。
- ⑤当容器的关闭的时候，会调用Bean的销毁方法（需要进行配置销毁的方法）。
-
示例：
-
Book.java
package com.sunxiaping;
public class Book {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
System.out.println("②调用setter方法设置属性值");
this.name = name;
}
public Book() {
System.out.println("①无参构造方法");
}
public void init() {
System.out.println("③这是初始化方法...");
}
public void destroy() {
System.out.println("⑤这是销毁的方法...");
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
init-method配置初始化方法
destroy-method配置销毁方法
-->
<bean id="book" class="com.sunxiaping.Book" init-method="init" destroy-method="destroy">
<property name="name" value="哈哈"/>
</bean>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//④调用Bean对象
Book book = context.getBean("book", Book.class);
System.out.println("④调用Bean对象" + book);
//手动调用让容器关闭
context.close();
}
}
-
后置处理器：会在Bean的初始化前后处理，将Bean传递给Bean的后置处理器方法
-
添加后置处理器的Bean的生命周期：
- ①通过构造器创建Bean实例（默认是通过无参构造器）
- ②为Bean的属性设置值和对其他Bean的引用（调用Setter方法）
- ③将Bean实例传递给Bean的后置处理器的方法。
- ④调用Bean的初始化的方法（需要进行配置初始化的方法）。
- ⑤将Bean实例传递给Bean的后置处理器的方法。
- ⑥使用Bean对象。
- ⑦当容器的关闭的时候，会调用Bean的销毁方法（需要进行配置销毁的方法）。
-
示例：只需要让类实现BeanPostProcessor，并重写其中的方法即可。
-
Book.java
package com.sunxiaping;
public class Book {
public void init(){
System.out.println("Book初始化...");
}
}
- Demo.java
package com.sunxiaping;
public class Demo {
public void init(){
System.out.println("Demo初始化...");
}
}
- MyBeanPostProcessor.java
package com.sunxiaping;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("初始化前...");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("初始化后...");
return bean;
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="book" class="com.sunxiaping.Book" init-method="init" ></bean>
<bean id="demo" class="com.sunxiaping.Demo" init-method="init"></bean>
<!--配置后置处理器-->
<bean id="myBeanPostProcessor" class="com.sunxiaping.MyBeanPostProcessor"></bean>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
}
}
2.3.3.5 自动装配
-
根据指定装配规则（属性名称或属性类型），Spring自动将匹配的属性值进行注入。
-
示例：根据属性名称自动注入
-
Dept.java
package com.sunxiaping;
import java.io.Serializable;
public class Dept implements Serializable {
@Override
public String toString() {
return "Dept{}";
}
}
- Employee.java
package com.sunxiaping;
import java.io.Serializable;
public class Employee implements Serializable {
private Dept dept;
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Employee{" +
"dept=" + dept +
'}';
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="dept" class="com.sunxiaping.Dept"></bean>
<!--
实现自动装配
bean标签中有属性autowire：
- 属性值 byName，根据属性名注入，注入Bean的id值要和类属性一致
- 属性值 byType，根据属性类型注入，注入Bean的类型要和类属性类型一致
-->
<bean id="emp" class="com.sunxiaping.Employee" autowire="byName"></bean>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class EmployeeTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Employee employee = context.getBean("emp",Employee.class);
System.out.println("employee = " + employee);
}
}
2.3.3.6 外部属性文件
- 示例：通过引入外部属性文件配置数据库连接池
- 导入数据库连接池的Maven坐标
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.23</version>
</dependency>
- db.properties
jdbc.url=jdgc:mysql://localhost:3306/db01
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc,password=123456
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 引入外部属性文件 -->
<context:property-placeholder location="db.properties"></context:property-placeholder>
<!-- 配置数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClass}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.user}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
</beans>
2.3.4 基于注解方式进行Bean管理的操作
2.3.4.1 什么是注解？
- 注解是代码的一种特殊标记，注解可以作用在类、方法和属性上面。
- 语法：
@注解名称(属性名称=属性值,属性名称=属性值...)
- 使用注解的目的，是简化XML的配置。
2.3.4.2 Spring针对Bean管理中创建对象提供的注解
- @Component
- @Service
- @Controller
- @Repository
上面的四个注解功能是一样的，都可以用来创建Bean实例。
2.3.4.3 基于注解方式创建对象
- 示例：
- UserService.java
package com.sunxiaping.service;
import org.springframework.stereotype.Service;
/**
* 在注解里面value属性值可以省略不写，默认值是类名首字母小写
*/
@Service(value = "userService")
public class UserService {
public void add() {
System.out.println("UserService ...");
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--
开启组件扫描
如果扫描多个包，多个包之间使用,隔开
如果扫描多个包，可以使用扫描包的是上层目录
-->
<context:component-scan base-package="com.sunxiaping"></context:component-scan>
</beans>
- 测试：
package com.sunxiaping;
import com.sunxiaping.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class EmployeeTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
2.3.4.4 组件扫描配置
- 示例：applicaitonContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--
默认情况下，如果不加use-default-filters="false"，则表示使用默认的filter，而默认的filter是扫描指定包下的所有组件
如果加了use-default-filters="false"，则表示不使用默认的filter，自已配置filter
context:include-filter，设置扫描那些内容
-->
<context:component-scan base-package="com.sunxiaping" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
</beans>
- 示例：applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--
context:exclude-filter 设置不扫描那些内容
-->
<context:component-scan base-package="com.sunxiaping">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
</beans>
2.3.4.5 基于注解注入属性
-
Spring注入属性提供的注解：
- @Autowired：根据属性类型进行自动装配。
- @Qualifier：根据属性名称进入注入。
- @Resource：可以根据类型注入，也可以根据名称注入。
- @Value：注入普通类型属性。
-
示例：@Autowired注解的使用
-
UserDao.java
package com.sunxiaping.dao;
public interface UserDao {
void add();
}
- UserDaoImpl.java
package com.sunxiaping.dao.impl;
import com.sunxiaping.dao.UserDao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("UserDaoImpl。。。add。。。");
}
}
- UserService.java
package com.sunxiaping.service;
public interface UserService {
void add();
}
- UserServiceImpl.java
package com.sunxiaping.service.impl;
import com.sunxiaping.dao.UserDao;
import com.sunxiaping.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserService {
//@Autowired按照类型注入
@Autowired
private UserDao userDao;
@Override
public void add() {
System.out.println("UserServiceImpl...add...");
userDao.add();
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.sunxiaping"></context:component-scan>
</beans>
- 测试：
package com.sunxiaping;
import com.sunxiaping.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Spring5Test {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userServiceImpl", UserService.class);
userService.add();
}
}
- 示例：@Qualifier注解的使用
- UserDao.java
package com.sunxiaping.dao;
public interface UserDao {
void add();
}
- UserDaoImpl.java
package com.sunxiaping.dao.impl;
import com.sunxiaping.dao.UserDao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("UserDaoImpl。。。add。。。");
}
}
- UserService.java
package com.sunxiaping.service;
public interface UserService {
void add();
}
- UserServiceImpl.java
package com.sunxiaping.service.impl;
import com.sunxiaping.dao.UserDao;
import com.sunxiaping.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserService {
//@Qualifier注解按照属性名称注入，其中属性value的值是要注入Bean的id
//@Qualifier注解要和@Autowired配合使用
@Autowired
@Qualifier(value = "userDaoImpl")
private UserDao userDao;
@Override
public void add() {
System.out.println("UserServiceImpl...add...");
userDao.add();
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.sunxiaping"></context:component-scan>
</beans>
- 测试：
package com.sunxiaping;
import com.sunxiaping.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Spring5Test {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userServiceImpl", UserService.class);
userService.add();
}
}
- 示例：@Resource注解的使用
- UserDao.java
package com.sunxiaping.dao;
public interface UserDao {
void add();
}
- UserDaoImpl.java
package com.sunxiaping.dao.impl;
import com.sunxiaping.dao.UserDao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("UserDaoImpl。。。add。。。");
}
}
- UserService.java
package com.sunxiaping.service;
public interface UserService {
void add();
}
- UserServiceImpl.java
package com.sunxiaping.service.impl;
import com.sunxiaping.dao.UserDao;
import com.sunxiaping.service.UserService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
public class UserServiceImpl implements UserService {
//@Resource注解如果不写name属性，那么就是按照类型注入
//@Resource注解如果写name属性，那么就是按照名称注入
@Resource(name = "userDaoImpl")
private UserDao userDao;
@Override
public void add() {
System.out.println("UserServiceImpl...add...");
userDao.add();
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.sunxiaping"></context:component-scan>
</beans>
- 测试：
package com.sunxiaping;
import com.sunxiaping.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Spring5Test {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userServiceImpl", UserService.class);
userService.add();
}
}
2.3.4.6 完全注解开发
-
开发步骤：
- ①创建一个配置类，用来替代applicationContext.xml文件。
- ②测试的时候，使用的是AnnotationConfigApplicationContext，而不是ClassPathXmlApplicationContext。
-
示例：
-
UserDao.java
package com.sunxiaping.dao;
public interface UserDao {
void add();
}
- UserDaoImpl.java
package com.sunxiaping.dao.impl;
import com.sunxiaping.dao.UserDao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("UserDaoImpl。。。add。。。");
}
}
- UserService.java
package com.sunxiaping.service;
public interface UserService {
void add();
}
- UserServiceImpl.java
package com.sunxiaping.service.impl;
import com.sunxiaping.dao.UserDao;
import com.sunxiaping.service.UserService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
public class UserServiceImpl implements UserService {
//@Resource注解如果不写name属性，那么就是按照类型注入
//@Resource注解如果写name属性，那么就是按照名称注入
@Resource(name = "userDaoImpl")
private UserDao userDao;
@Override
public void add() {
System.out.println("UserServiceImpl...add...");
userDao.add();
}
}
- SpringConfing.java
package com.sunxiaping.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
/**
* 配置类，相当于applicationContext.xml
*/
@Configuration
@ComponentScan(basePackages = "com.sunxiaping")
public class SpringConfig {
}
- 测试：
package com.sunxiaping;
import com.sunxiaping.config.SpringConfig;
import com.sunxiaping.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Spring5Test {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userServiceImpl", UserService.class);
userService.add();
}
}
3 AOP
3.1 概念
- 面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
3.2 AOP底层原理
-
使用JDK的动态代理。
-
使用CGLIB的动态代理。
-
示例：使用JDK的动态代理
-
UserDao.java
package com.sunxiaping.dao;
public interface UserDao {
int add(int a, int b);
String update(String id);
}
- UserDaoImpl.java
package com.sunxiaping.dao.impl;
import com.sunxiaping.dao.UserDao;
public class UserDaoImpl implements UserDao {
@Override
public int add(int a, int b) {
System.out.println("add...执行了");
return a + b;
}
@Override
public String update(String id) {
System.out.println("update...执行了");
return id;
}
}
- 测试：
package com.sunxiaping;
import com.sunxiaping.dao.UserDao;
import com.sunxiaping.dao.impl.UserDaoImpl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class SpringTest {
public static void main(String[] args) {
UserDao userDao = new UserDaoImpl();
UserDao proxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("在" + method.getName() + "之前执行");
Object result = method.invoke(userDao, args);
System.out.println("在" + method.getName() + "之后执行");
return result;
}
});
int result = proxy.add(1, 2);
System.out.println("result = " + result);
String id = proxy.update("1");
System.out.println("id = " + id);
}
}
3.3 AOP术语
- 连接点：类里面那些方法可以被增强，这些方法称为连接点。
- 切入点：实际被真正增强的方法，称为切入点。
- 通知（增强）：实际增强的逻辑部分，称为通知（增强）。
- 通知的类型：
- 前置通知。
- 后置通知。
- 环绕通知。
- 异常通知。
- 最终通知。
- 切面：把通知应用到切入点的过程。
3.4 AOP的准备
-
在Spring框架一般基于AspectJ（AspectJ不是Spring的部分，是一个独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP的操作）来实现AOP操作。
-
导入相关jar包的Maven坐标：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.23</version>
</dependency>
-
切入点表达式：
- 作用：对哪个类里面的哪个方法进行增强。
- 语法：
execution([权限修饰符][返回类型][类全路径][方法名称([参数列表])])-
例子：
- 对com.sunxiaping.dao.BookDao类中add方法进行增强：
execution(* com.sunxiaping.dao.BookDao.add(..))- 对com.sunxiaping.dao.BookDao类中的所有方法进行增强：
execution(* com.sunxiaping.dao.BookDao.*(..))
3.5 AspectJ注解形式应用示例
- 示例：
- 被增强的类User.java
package com.sunxiaping;
import org.springframework.stereotype.Component;
/**
* 被增强类
*/
@Component
public class User {
public void add(){
System.out.println("add ...");
}
}
- 增强的类，即代理类UserAspect.java
package com.sunxiaping;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* 增强的类
*/
@Component
@Aspect //生成代理对象
@Order(1) //在多个增强类对同一个方法进行增强，设置增强类的优先级，@Order中的value属性值越小优先级越高
public class UserAspect {
/**
* 切入点表达式
*/
@Pointcut("execution(* com.sunxiaping.User.add(..))")
public void pointcut() {
}
/**
* 前置通知
*/
@Before(value = "pointcut()")
public void beforeAdd() {
System.out.println("before add ...");
}
/**
* 后置通知
*/
@AfterReturning(value = "pointcut()", returning = "obj")
public void afterReturningAdd(Object obj) {
System.out.println("afterReturning add ..." + obj);
}
/**
* 环绕通知
*/
@Around(value = "pointcut()")
public void aroundAdd(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前");
proceedingJoinPoint.proceed();
System.out.println("环绕之后");
}
/**
* 异常通知
*/
@AfterThrowing(value = "pointcut()", throwing = "ex")
public void afterThrowingAdd(Exception ex) {
System.out.println("afterThrowing add ..." + ex);
}
/**
* 最终通知
*/
@After(value = "pointcut()")
public void afterAdd() {
System.out.println("after add ...");
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启组件扫描 -->
<context:component-scan base-package="com.sunxiaping"></context:component-scan>
<!-- 开启aspectj生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
User user = context.getBean(User.class);
user.add();
}
}
3.6 完全使用注解开发AspectJ
- 示例：
- 被增强的类User.java
package com.sunxiaping;
import org.springframework.stereotype.Component;
/**
* 被增强类
*/
@Component
public class User {
public void add(){
System.out.println("add ...");
}
}
- 增强的类，即代理类UserAspect.java
package com.sunxiaping;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* 增强的类
*/
@Component
@Aspect //生成代理对象
@Order(1) //在多个增强类对同一个方法进行增强，设置增强类的优先级，@Order中的value属性值越小优先级越高
public class UserAspect {
/**
* 切入点表达式
*/
@Pointcut("execution(* com.sunxiaping.User.add(..))")
public void pointcut() {
}
/**
* 前置通知
*/
@Before(value = "pointcut()")
public void beforeAdd() {
System.out.println("before add ...");
}
/**
* 后置通知
*/
@AfterReturning(value = "pointcut()", returning = "obj")
public void afterReturningAdd(Object obj) {
System.out.println("afterReturning add ..." + obj);
}
/**
* 环绕通知
*/
@Around(value = "pointcut()")
public void aroundAdd(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前");
proceedingJoinPoint.proceed();
System.out.println("环绕之后");
}
/**
* 异常通知
*/
@AfterThrowing(value = "pointcut()", throwing = "ex")
public void afterThrowingAdd(Exception ex) {
System.out.println("afterThrowing add ..." + ex);
}
/**
* 最终通知
*/
@After(value = "pointcut()")
public void afterAdd() {
System.out.println("after add ...");
}
}
- SpringConfig.java
package com.sunxiaping;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@EnableAspectJAutoProxy(proxyTargetClass = true)
@ComponentScan(basePackages = "com.sunxiaping")
@Configurable
public class SpringConfig {
}
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class SpringTest {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
User user = context.getBean(User.class);
user.add();
}
}
3.7 XML形式应用示例
- 被增强的类User.java
package com.sunxiaping;
/**
* 被增强类
*/
public class User {
public void add(){
System.out.println("add ...");
}
}
- 增强的类，即代理类UserAspect.java
package com.sunxiaping;
/**
* 增强的类
*/
public class UserAspect {
/**
* 前置通知
*/
public void beforeAdd() {
System.out.println("before add ...");
}
}
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="user" class="com.sunxiaping.User"></bean>
<bean id="userAspect" class="com.sunxiaping.UserAspect"></bean>
<!-- 配置aop -->
<aop:config>
<!-- 配置切入点 -->
<aop:pointcut id="pointcut" expression="execution(* com.sunxiaping.User.add(..)))"/>
<!-- 配置切面 -->
<aop:aspect ref="userAspect">
<!-- 配置增强作用在具体的方法上 -->
<aop:before method="beforeAdd" pointcut-ref="pointcut"></aop:before>
</aop:aspect>
</aop:config>
</beans>
- 测试：
package com.sunxiaping;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
User user = context.getBean(User.class);
user.add();
}
}
4 JdbcTemplate
4.1 概念
- Spring框架对JDBC进行了封装，使用JdbcTemplate方便实现对数据库的操作。
4.2 准备工作
- 导入相关jar包的Maven坐标：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.23</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.19</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
- sql语句：
DROP TABLE IF EXISTS `book`;
CREATE TABLE `book` (
`id` bigint(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
`price` double NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
- Book.java
package com.sunxiaping.domain;
import java.io.Serializable;
/**
* 图书
*/
public class Book implements Serializable {
/**
* 主键
*/
private Long id;
/**
* 书名
*/
private String name;
/**
* 价格
*/
private Double price;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"id=" + id +
", name='" + name + '\'' +
", price=" + price +
'}';
}
}
- db.properties
jdbc.url=jdbc:mysql://192.168.1.107:33060/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true
jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=123456
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.sunxiaping"></context:component-scan>
<!-- 导入数据库连接信息 -->
<context:property-placeholder location="db.properties"></context:property-placeholder>
<!-- 配置数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClass}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- 配置jdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>
4.3 JdbcTemplate的CRUD
- BookDao.java
package com.sunxiaping.dao;
import com.sunxiaping.domain.Book;
import java.util.List;
public interface BookDao {
/**
* 新增
*
* @param book
*/
void add(Book book);
/**
* 更新
*
* @param book
*/
void update(Book book);
/**
* 删除
*
* @param id
*/
void delete(Long id);
/**
* 查询个数
*
* @return
*/
Long count();
/**
* 查询所有信息
*
* @return
*/
List<Book> findAll();
/**
* 根据主键查询信息
*
* @param id
* @return
*/
Book findOne(Long id);
}
- BookDaoImpl.java
package com.sunxiaping.dao.impl;
import com.sunxiaping.dao.BookDao;
import com.sunxiaping.domain.Book;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public class BookDaoImpl implements BookDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void add(Book book) {
jdbcTemplate.update(" insert into book (name,price) values (?,?) ", book.getName(), book.getPrice());
}
@Override
public void update(Book book) {
jdbcTemplate.update(" update book set name =?,price =? where id = ? ", book.getName(), book.getPrice(), book.getId());
}
@Override
public void delete(Long id) {
jdbcTemplate.update(" delete from book where id =? ", id);
}
@Override
public Long count() {
return jdbcTemplate.queryForObject(" select count(*) from book ", Long.class);
}
@Override
public List<Book> findAll() {
return jdbcTemplate.query(" select * from book ", new BeanPropertyRowMapper<>(Book.class));
}
@Override
public Book findOne(Long id) {
return jdbcTemplate.queryForObject(" select * from book where id = ? ", new BeanPropertyRowMapper<>(Book.class), id);
}
}
- BookService.java
package com.sunxiaping.service;
import com.sunxiaping.domain.Book;
import java.util.List;
public interface BookService {
/**
* 新增图书
*
* @param book
*/
void addBook(Book book);
/**
* 更新图书
*
* @param book
*/
void updateBook(Book book);
/**
* 删除图书
*
* @param id
*/
void deleteBook(Long id);
/**
* 查询数据库中有多少本书
*
* @return
*/
Long count();
/**
* 查询图书信息
*
* @param id
* @return
*/
Book view(Long id);
/**
* 查询所有图书信息
*
* @return
*/
List<Book> findAllBookList();
}
- BookServiceImpl.java
package com.sunxiaping.service.impl;
import com.sunxiaping.dao.BookDao;
import com.sunxiaping.domain.Book;
import com.sunxiaping.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class BookServiceImpl implements BookService {
@Autowired
private BookDao bookDao;
@Override
public void addBook(Book book) {
bookDao.add(book);
}
@Override
public void updateBook(Book book) {
bookDao.update(book);
}
@Override
public void deleteBook(Long id) {
bookDao.delete(id);
}
@Override
public Long count() {
return bookDao.count();
}
@Override
public Book view(Long id) {
return bookDao.findOne(id);
}
@Override
public List<Book> findAllBookList() {
return bookDao.findAll();
}
}
- 测试：
package com.sunxiaping;
import com.sunxiaping.domain.Book;
import com.sunxiaping.service.BookService;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
public class Spring5Test {
private ApplicationContext context = null;
private BookService bookService = null;
@Before
public void before() {
context = new ClassPathXmlApplicationContext("applicationContext.xml");
bookService = context.getBean(BookService.class);
}
@Test
public void testAdd() {
Book book = new Book();
book.setName("西游记");
book.setPrice(20.5);
bookService.addBook(book);
}
@Test
public void testUpdate() {
Book book = new Book();
book.setId(1L);
book.setName("西游记");
book.setPrice(50.0);
bookService.updateBook(book);
}
@Test
public void testDelete() {
bookService.deleteBook(1L);
}
@Test
public void testCount() {
Long count = bookService.count();
System.out.println("count = " + count);
}
@Test
public void testView(){
Book book = bookService.view(1L);
System.out.println("book = " + book);
}
@Test
public void testFindAllBookList(){
List<Book> allBookList = bookService.findAllBookList();
System.out.println("allBookList = " + allBookList);
}
}
5 事务管理
5.1 概念
- 事务是数据库操作最基本的单元，逻辑上的一组操作，要么全部成功，要么全部失败。
5.2 事务的特性
- 原子性
- 一致性
- 隔离性
- 持久性
5.3 准备工作
- account.sql
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
`username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL COMMENT '姓名',
`money` double NULL DEFAULT NULL COMMENT '账户余额',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `account` VALUES (1, 'lucy', 1000);
INSERT INTO `account` VALUES (2, 'marry', 1000);
- 导入相关jar包的Maven坐标：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.23</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.19</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
- Account.java
package com.sunxiaping.domain;
/**
* 账户
*/
public class Account {
/**
* 主键
*/
private Long id;
/**
* 姓名
*/
private String name;
/**
* 账户余额
*/
private Double money;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
- db.properties
jdbc.url=jdbc:mysql://192.168.1.107:33060/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true
jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=123456
- applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.sunxiaping"></context:component-scan>
<!-- 导入数据库连接信息 -->
<context:property-placeholder location="db.properties"></context:property-placeholder>
<!-- 配置数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClass}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- 配置jdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>
5.4 事务操作介绍
5.4.1 概述
-
事务添加到JavaEE三层结构中的Service层（业务逻辑层）。
-
在Spring中进行事务管理操作有两种方式：
- 编程式事务管理。
- 声明式事务管理（经常使用）。
-
声明式事务管理：
- 基于注解方式（经常使用）。
- 基于XML配置文件方式。
-
Spring事务管理API
- Spring提供了一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类。
-
@Transaction注解可以添加在类上面，也可以放在方法上面。
- 如果添加在类上面，这个类里面的所有的方法都添加了事务。
- 如果添加在方法上面，则这个方法添加了事务。
- 源码：
package org.springframework.transaction.annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import org.springframework.core.annotation.AliasFor; @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface Transactional { @AliasFor("transactionManager") String value() default ""; @AliasFor("value") String transactionManager() default ""; //传播行为 Propagation propagation() default Propagation.REQUIRED; //事务隔离级别 Isolation isolation() default Isolation.DEFAULT; //超时时间 int timeout() default -1; //是否只读 boolean readOnly() default false; //回滚 Class<? extends Throwable>[] rollbackFor() default {}; String[] rollbackForClassName() default {}; //不回滚 Class<? extends Throwable>[] noRollbackFor() default {}; String[] noRollbackForClassName() default {}; }-
propagation：事务的传播行为。
- 多事务方法（对数据库表数据进行变化的操作）直接进行调用，这个过程中事务是如何进行管理的。
@Transactional public void add(){ //调用update方法 update(); } public void update(){}- 属性：
- REQUIRED：
- 如果add方法本身有事务，则调用update方法之后，update使用当前add方法里面的事务。
- 如果add方法本身没有事务，调用update方法之后，会创建新的事务。
- REQUIRED_NEW：
- 使用add方法调用update方法，无论add是否有事务，都会创建新的事务。
- REQUIRED：
-
isolation：事务隔离级别。
- 多事务操作之间不会产生影响。
- 如果不考虑隔离性，会产生脏读、不可重复读、虚读。
- 脏读：一个未提交的事务读到另一个事务未提交的事务（针对update）。
- 不可重复读：一个未提交的事务读到另一个提交事务的修改数据（针对update），前后多次读取，导致数据内容不一致。
- 幻读：一个未提交的事务读到了另一个提交事务的添加数据（针对insert），前后多次读取，数据总量不一致。
- 通过设置事务的隔离级别，可以解决脏读问题。
- READ UNCOMMITTED：会出现脏读、不可重复读、幻读。
- READ COMMITTED：会出现不可重复读、幻读。
- REPEATABLE READ：会出现幻读。
- SERIALIZABLE：不会出现问题。
-
timeout：超时时间。
-
事务需要在一定时间内进行提交，如果不提交就进行回滚。
-
在Spring中，默认值是-1（不回滚），设置时间以秒单位进行计算。
-
-
readOnly：是否只读。
-
默认值是false，表示可以查询、添加、修改、删除操作。 -
如果设置readOnly为true，就只能查询。 -
rollbackFor：回滚。
- 设置出现了那些异常进行事务回滚。
-
noRollbackFor：不回滚。
- 设置那些异常不进行事务回滚。
-
5.4.2 基于注解方式的声明式事务管理
- 在Spring的配置文件applicationContext.xml中配置事务管理器
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
- 在Spring的配置文件applicationContext.xml中，开启事务注解
<!-- 开启事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
- 完整的applicationContext.xml文件信息
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.sunxiaping"></context:component-scan>
<!-- 导入数据库连接信息 -->
<context:property-placeholder location="db.properties"></context:property-placeholder>
<!-- 配置数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClass}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- 配置jdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 开启事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
- AccountDao.java
package com.sunxiaping.dao;
import com.sunxiaping.domain.Account;
public interface AccountDao {
/**
* 转入
*
* @param account
* @param money
*/
void addMoney(Account account, Double money);
/**
* 转出
*
* @param account
* @param money
*/
void reduceMoney(Account account, Double money);
}
- AccountDaoImpl.java
package com.sunxiaping.dao.impl;
import com.sunxiaping.dao.AccountDao;
import com.sunxiaping.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
public class AccountDaoImpl implements AccountDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public void addMoney(Account account, Double money) {
jdbcTemplate.update(" update account set money = money + ? where username = ? ", money, account.getName());
}
@Override
public void reduceMoney(Account account, Double money) {
jdbcTemplate.update(" update account set money = money - ? where username = ? ", money, account.getName());
}
}
- AccountService.java
package com.sunxiaping.service;
public interface AccountService {
/**
* 转账
*
* @param from
* @param target
* @param money
*/
void transfer(String from, String target, Double money);
}
- AccountServiceImpl.java
package com.sunxiaping.service.impl;
import com.sunxiaping.dao.AccountDao;
import com.sunxiaping.domain.Account;
import com.sunxiaping.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Transactional
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Override
public void transfer(String from, String target, Double money) {
Account targetAccount = new Account();
targetAccount.setName(target);
accountDao.addMoney(targetAccount, money);
int i = 100 / 0;
Account fromAccount = new Account();
fromAccount.setName(from);
accountDao.reduceMoney(fromAccount, money);
}
}
- 测试：
package com.sunxiaping;
import com.sunxiaping.service.AccountService;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringTest {
private AccountService accountService = null;
@Before
public void before(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
accountService = context.getBean(AccountService.class);
}
@Test
public void test(){
accountService.transfer("lucy","marrry",100.00);
}
}
5.4.3 基于XML配置文件方式的声明式事务管理
- 在Spring的配置文件applicationContext.xml中配置事务管理器
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
- 在Spring的配置文件applicationContext.xml中配置通知
<!-- 配置通知 -->
<tx:advice id="txAdvice">
<!-- 配置事务参数 -->
<tx:attributes>
<!-- 指定那种规则的方法上面添加事务 -->
<tx:method name="add*" />
<tx:method name="update*" />
<tx:method name="delete*" />
</tx:attributes>
</tx:advice>
- 在Spring的配置文件applicationContext.xml中配置切入点和通知
<!-- 配置切入点和切面 -->
<aop:config>
<!-- 配置切入点 -->
<aop:pointcut id="pointcut" expression="execution(* com.sunxiaping.service.impl.AccountServiceImpl.*(..))"/>
<!-- 配置切面 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"></aop:advisor>
</aop:config>
- 完整的applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns="http://www.springframework.org/schema/beans"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 开启注解扫描 -->
<context:component-scan base-package="com.sunxiaping"></context:component-scan>
<!-- 导入数据库连接信息 -->
<context:property-placeholder location="db.properties"></context:property-placeholder>
<!-- 配置数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClass}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- 配置jdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置通知 -->
<tx:advice id="txAdvice">
<!-- 配置事务参数 -->
<tx:attributes>
<!-- 指定那种规则的方法上面添加事务 -->
<tx:method name="add*"/>
<tx:method name="update*"/>
<tx:method name="delete*"/>
</tx:attributes>
</tx:advice>
<!-- 配置切入点和切面 -->
<aop:config>
<!-- 配置切入点 -->
<aop:pointcut id="pointcut" expression="execution(* com.sunxiaping.service.impl.AccountServiceImpl.*(..))"/>
<!-- 配置切面 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"></aop:advisor>
</aop:config>
</beans>
5.4.4 完全注解方式的声明式事务管理
- SpringConfig.java
package com.sunxiaping.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;
@Configuration
@ComponentScan(basePackages = "com.sunxiaping")
@EnableTransactionManagement //开启事务
public class SpringConfig {
/**
* 连接池
*
* @return
*/
@Bean
public DataSource dataSource() {
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
druidDataSource.setUrl("jdbc:mysql://192.168.134.100:3306/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true");
druidDataSource.setUsername("root");
druidDataSource.setPassword("123456");
return dataSource();
}
/**
* JdbcTemplate
*
* @return
*/
@Bean
public JdbcTemplate jdbcTemplate() {
JdbcTemplate jdbcTemplate = new JdbcTemplate();
jdbcTemplate.setDataSource(dataSource());
return jdbcTemplate;
}
/**
* 事务管理器
*
* @return
*/
@Bean
public TransactionManager transactionManager() {
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource());
return transactionManager;
}
}
6 Spring5新特性
6.1 概述
- 整个Spring5框架基于JDK8，运行时兼容JDK9，许多不建议使用的类和方法在代码库中删除。
- Spring5框架自带了通用的日志封装。
- Spring5框架已经移除了Log4jConfigListener，官方建议使用Log4j2。
- Spring5框架核心容器支持@Nullable注解。
- @Nullable可以使用在方法、属性和参数上面。
- 如果@Nullable用在方法上面，表示方法的返回值可以为null。
- 如果@Nullable用在属性上面，表示属性值可以为null。
- 如果@Nullable用在方法参数里面，表示参数可以为null。
- @Nullable可以使用在方法、属性和参数上面。
- Spring5核心容器支持函数式风格GenericApplicationContext/AnnotationConfigApplicationContext。
- Spring5支持整合Junit5。
- Spring5支持WebFlux。
6.2 Spring5整合Log4j2
- 导入log4j相关jar包的Maven坐标
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.13.3</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.13.3</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.30</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
<version>2.13.3</version>
</dependency>
- 创建log4j2的配置文件(log4j2.xml)
<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
<!--先定义所有的appender-->
<appenders>
<!--输出日志信息到控制台-->
<console name="Console" target="SYSTEM_OUT">
<!--控制日志输出的格式-->
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
</console>
</appenders>
<!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
<!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
<loggers>
<root level="info">
<appender-ref ref="Console"/>
</root>
</loggers>
</configuration>
- 测试：
package com.sunxiaping;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Spring5Test {
private static final Logger LOGGER = LoggerFactory.getLogger(Spring5Test.class);
@Test
public void test() {
LOGGER.info("info....");
LOGGER.debug("debug...");
}
}
6.3 Spring5支持函数式风格
- 示例：
- Person.java
package com.sunxiaping;
import org.springframework.stereotype.Component;
@Component
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
- 测试：
package com.sunxiaping;
import org.junit.Test;
import org.springframework.context.support.GenericApplicationContext;
public class Spring5Test {
/**
* 函数式风格创建对象，交给Spring管理
*/
@Test
public void test() {
//创建GenericApplicationContext对象
GenericApplicationContext context = new GenericApplicationContext();
//调用context的refresh()方法
context.refresh();
context.registerBean("person",Person.class,()->new Person());
//获取在Spring注册的对象
Person person = context.getBean(Person.class);
System.out.println(person);
}
}
6.4 Spring5整合Junit
6.4.1 Spring5整合Junit4
- 导入junit4和Spring整合junit4相关jar包的Maven坐标：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
- 在测试类中，使用注解方式完成
package com.sunxiaping;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
//指定Junit的版本
@RunWith(SpringJUnit4ClassRunner.class)
//加载配置文件
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class Spring5Test {
@Autowired
private Person person;
@Test
public void test(){
System.out.println(person);
}
}
6.4.2 Spring5整合Junit5
- 导入junit5和Spring整合junit4相关jar包的Maven坐标：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.6.2</version>
<scope>test</scope>
</dependency>
- 在测试类中，使用注解方式完成
package com.sunxiaping;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
@ExtendWith(SpringExtension.class)
//加载配置文件
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class Spring5Test {
@Autowired
private Person person;
@Test
public void test(){
System.out.println(person);
}
}
6.5 WebFlux
6.5.1 Spring WebFlux介绍
-
Spring Webflux是Spring5添加的新的模块，用于web开发的，功能和SpringMVC类似，Webflux使用当前一种比较流行的响应式编程而出现的框架。
-
使用传统的web框架，比如Spring MVC，是基于Servlet容器；Webflux是一种异步非阻塞的框架，异步非阻塞是在Servlet3.1后才开始支持的，Webflux是基于Reactor的相关API实现的。
-
异步非阻塞：
- 异步和同步是针对调用者来说的。
- 当调用者发送请求，如果要等着对方回应之后才做其他的事情，这个现象称为同步。
- 当调用者发送请求，如果不需要等着对方回应之后就可以做其他的事情，这个现象称为异步。
- 阻塞和非阻塞是针对被调用者而言的。
- 当被调用者收到一个请求之后，做完请求任务之后才给出反馈就是阻塞。
- 当被调用者收到一个请求之后，马上给出反馈然后再去做请求任务就是非阻塞。
- 异步和同步是针对调用者来说的。
-
webflux的特点：
- 非阻塞式：在有限的资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程。
- 函数式编程：Spring5框架基于JDK8，webflux中可以使用JDK8函数式编程方式实现路由请求。
-
Spring MVC VS Spring Webflux
SpringMVC和SpringWebflux都可以使用注解方式，都运行在Tomcat等容器中。
SpringMVC采用命令式编程，SpringWebflux采用异步响应式编程。
6.5.2 响应式编程
6.5.2.1 什么是响应式编程？
- 响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。
- 电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。
6.5.2.2 Java8及之前版本
-
提供了观察者模式的两个类Observer和Observable。
-
示例：
package com.sunxiaping.springbootspring5.reactor8;
import java.util.Observable;
public class ObserverDemo extends Observable {
public static void main(String[] args) {
ObserverDemo observerDemo = new ObserverDemo();
//添加观察者
observerDemo.addObserver((o, arg) -> {
System.out.println("发生了变化");
});
observerDemo.addObserver((o, arg) -> {
System.out.println("收到被观察者的通知，准备发生改变");
});
//数据变化
observerDemo.setChanged();
//通知
observerDemo.notifyObservers();
}
}
6.5.2.3 Reactor实现
- 响应式编程的操作中，Reactor是满足Reactive规范的一个框架，Webflux的核心是Reactor。
- Reactor有两个核心类：Mono和Flux，这两个类都实现了接口Publisher，提供丰富的操作符。Flux对象实现发布者，返回N个元素;Mono对象实现发布者，返回0或1个元素。
- Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发送三种数据信号：元素值,错误信号,完成信号。错误信号和完成信号都代表终止信号，终止信号用来告诉订阅者数据流已经结束了，错误信号终止数据流同时把错误的信息传递给订阅者。
- 示例：演示Flux和Mono
- 导入reactor的jar包的Maven坐标：
<dependency>
<groupId>io.projectreactor</groupId>
<artifactId>reactor-core</artifactId>
<version>3.1.5.RELEASE</version>
</dependency>
- ReactorTest.java
package com.sunxiaping.springbootspring5.reactor8;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class ReactorTest {
public static void main(String[] args) {
//just方法，直接声明
Flux.just(1,2,3,4);
Mono.just(1);
//其他方法
Integer[] arr = {1,2,3};
Flux.fromArray(arr);
List<Integer> list = Arrays.asList(1,2,3);
Flux.fromIterable(list);
Stream<Integer> stream = list.stream();
Flux.fromStream(stream);
}
}
-
三种信号的特点：
- 错误信号和完成信号都是终止信号，不能共存的。
- 如果没有发送任何元素值，而是直接发送错误或者完成信息，表示是一个空的数据流。
- 如果没有错误信号，也没有完成信号，表示是无限数据流。
-
调用just或者其他方法只是申明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流，不订阅什么都不会发生的。
package com.sunxiaping.springbootspring5.reactor8;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class ReactorTest {
public static void main(String[] args) {
//just方法，直接声明
Flux.just(1,2,3,4).subscribe(System.out::println);
Mono.just(1).subscribe(System.out::println);
//其他方法
Integer[] arr = {1,2,3};
Flux.fromArray(arr).subscribe(System.out::println);
List<Integer> list = Arrays.asList(1,2,3);
Flux.fromIterable(list).subscribe(System.out::println);
Stream<Integer> stream = list.stream();
Flux.fromStream(stream).subscribe(System.out::println);
}
}
6.5.2.4 操作符
-
对数据流进行一道道的操作，称为操作符。比如工厂的流水线。
-
map：元素映射为新的元素。
- flatMap：元素映射为流。
6.5.3 WebFlux的执行流程和核心API
- SpringWebFlux基于Reactor，默认使用的容器是Netty，Netty是高性能的NIO框架，异步非阻塞的框架。
- BIO：
- NIO：
-
SpringWebFlux执行过程和SpringMVC执行过程类似。
- SpringWebFlux核心控制器DispatcherHandler，实现了WebHandler接口。
- WebHandler的源码如下：
package org.springframework.web.server; import reactor.core.publisher.Mono; public interface WebHandler { Mono<Void> handle(ServerWebExchange var1); }- DispatcherHandler，实现了handle方法，其源码片段如下：
public class DispatcherHandler implements WebHandler, ApplicationContextAware { //ServerWebExchange是HTTP的请求信息 public Mono<Void> handle(ServerWebExchange exchange) { return this.handlerMappings == null ? this.createNotFoundError() : Flux.fromIterable(this.handlerMappings).concatMap((mapping) -> { return mapping.getHandler(exchange);//根据请求地址获取对应的mapping }).next().switchIfEmpty(this.createNotFoundError()).flatMap((handler) -> { return this.invokeHandler(exchange, handler);//调用具体的业务方法 }).flatMap((result) -> { return this.handleResult(exchange, result);//处理的结果返回 }); } } -
SpringWebFlux里面的DispatcherHandler，负责请求的处理。
- HandlerMapping：请求查询到处理的方法。
- HandlerAdapter：真正负责请求处理。
- HandlerResultHandler：响应结果处理。
-
SpringWebFlux实现函数式编程，两个接口：RouterFunction（路由处理）和HandlerFunction（处理函数）。
6.5.4 SpringWebFlux(基于注解编程模型)
- 示例：以SpringBoot项目为例，使用SpringBoot2.x版本。
- 导入spring-boot-starter-webflux的jar包的Maven坐标：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
- User.java
package com.sunxiaping.springbootspring5.domain;
public class User {
private String username;
private String gender;
private Integer age;
public User() {
}
public User(String username, String gender, Integer age) {
this.username = username;
this.gender = gender;
this.age = age;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", gender='" + gender + '\'' +
", age=" + age +
'}';
}
}
- UserService.java
package com.sunxiaping.springbootspring5.service;
import com.sunxiaping.springbootspring5.domain.User;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
public interface UserService {
/**
* 根据id查询用户
*
* @param id
* @return
*/
Mono<User> findUserById(Integer id);
/**
* 查询所有用户
*
* @return
*/
Flux<User> findAllUser();
/**
* 添加用户
*
* @param userMono
* @return
*/
Mono<Void> saveUserInfo(Mono<User> userMono);
}
- UserServiceImpl.java
package com.sunxiaping.springbootspring5.service.impl;
import com.sunxiaping.springbootspring5.domain.User;
import com.sunxiaping.springbootspring5.service.UserService;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.HashMap;
import java.util.Map;
@Service
public class UserServiceImpl implements UserService {
private static Map<Integer, User> users = new HashMap<>();
static {
users.put(1, new User("lucy", "女", 20));
users.put(2, new User("marry", "女", 18));
users.put(3, new User("jack", "男", 45));
}
@Override
public Mono<User> findUserById(Integer id) {
return Mono.justOrEmpty(users.get(id));
}
@Override
public Flux<User> findAllUser() {
return Flux.fromIterable(users.values());
}
@Override
public Mono<Void> saveUserInfo(Mono<User> userMono) {
return userMono.doOnNext((user) -> {
Integer id = users.size() + 1;
users.put(id, user);
}).thenEmpty(Mono.empty());
}
}
- UserController.java
package com.sunxiaping.springbootspring5.web;
import com.sunxiaping.springbootspring5.domain.User;
import com.sunxiaping.springbootspring5.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@RestController
public class UserController {
@Autowired
private UserService userService;
/**
* 根据id查询用户信息
*
* @param id
* @return
*/
@GetMapping("/user/{id}")
public Mono<User> getUserId(@PathVariable("id") Integer id) {
return userService.findUserById(id);
}
/**
* 查询所有的用户信息
*
* @return
*/
@GetMapping("/users")
public Flux<User> findAllUser() {
return userService.findAllUser();
}
/**
* 新增用户信息
*
* @param user
* @return
*/
@PostMapping("/saveUser")
public Mono<Void> saveUser(@RequestBody User user) {
Mono<User> userMono = Mono.just(user);
return userService.saveUserInfo(userMono);
}
}
标签：void,sunxiaping,org,import,com,public,Spring5 来源： https://www.cnblogs.com/xuweiweiwoaini/p/13660065.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。