Spring

概述

Spring框架概述

轻量级开源JavaEE框架，为了解决企业复杂性
两个核心组成：
- IOC：控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
- AOP：面向切面（方面）编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发效率

IOC容器

IOC底层原理：
- 工厂
- 反射等
IOC接口：BeanFactory
IOC操作Bean管理：
- 基于XML
- 基于注解

Aop

AOP底层原理：动态代理
- 有接口：JDK动态代理
- 没有接口：GLIB动态代理
术语：
- 切入点：类里可以被增强的方法
- 增强（通知）：实际被真正增强的方法
- 切面：实际增强的逻辑部分
基于AspectJ实现AOP操作

JdbcTemplate

使用JdbcTemplate实现数据库CURD操作
使用JdbcTemplate实现数据库批量操作

事务管理

事务概念
重要概念：传播行为和隔离级别
声明式事务管理：
- 基于于注解实现
- 完全注解方式实现

Spring5 新功能

整合日志框架
@Nullable注解
函数式注册对象
整合JUnit5单元测试框架
SpringWebflux使用

AnnotationSpring

轻量级的开源的JavaEE框架

解决企业应用开发的复杂性

核心部分：

IOC：控制反转，把创建对象过程交给Spring进行管理
AOP：面向切面，不修改源代码进行功能增强

特点：

方便解耦，简化开发
AOP编程支持
方便程序测试
方便和其他框架进行整合
方便进行事务操作
降低API开发难度

IOC

控制反转：把对象创建和对象之间的调用过程，交给Spring进行管理

使用目的：降低耦合度

底层原理

xml解析，工厂模式，反射

IOC过程：

XML配置文件，配置创建的对象

1	`<bean id="dao" class="cc.mousse.UserDao"></bean>`

创建工厂类

class UserFactory {
	public static UserDao getDao {
    //XML解析
    String classValue = class属性值;
    //通过反射创建对象
    Class clazz = Class.forname(classValue);
    return (UserDao) clazz.newInstance();
  }
}

BeanFactory

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

Spring提供IOC容器实现两种方式：（两个接口）

BeanFactory：IOC容器基本实现，是Spring内部的使用接口
- 不提供开发人员进行使用
- 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能
- 一般由开发人员进行使用
- 加载配置文件时候就会把在配置文件对象进行创建
- 实现类：
  - FileSystemXmlApplicationContext：系统路径（全路径）
  - ClassPathXmllApplicationContext：类路径（src下）

Bean管理

指两个操作：

Spring创建对象
Spirng注入属性

基于XML

创建对象：

在spring配置文件中使用bean标签，标签里面添加对应属性就可以实现对象创建
在bean标签有很多属性，其中常用属性：
- id属性：唯一标识
- class属性：类全路径（包类路径）
创建对象时默认执行无参数构造方法完成对象创建

1 2	`<!--配置User对象创建--> <bean id="user" class="cc.mousse.User"></bean>`

注入属性：

DI：依赖注入（属性注入），IOC中的一种实现

先创建对象后注入属性

方式1：使用set方式注入

<!--set方法注入属性-->
<bean id="book" class="cc.mousse.Book">
    <!--使用property属性注入-->
    <!--name：属性名称-->
    <!--value：属性值-->
    <property name="BName" value="易筋经"></property>
    <property name="BAuthor" value="达摩老祖"></property>
</bean>

方式2：使用带参构造器进行注入

<!--带参构造器注入属性-->
<bean id="order" class="cc.mousse.Order">
    <constructor-arg name="oName" value="Mac"></constructor-arg>
    <constructor-arg name="address" value="CN"></constructor-arg>
</bean>

方式3：p名称空间注入，可简化基于xml配置方式

在配置文件中添加p名称空间

<?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标签中进行属性注入

1
2
3

<!--p名称空间注入属性-->
<bean id="book1" class="cc.mousse.Book" p:BName="九阳神功" p:BAuthor="无名氏">
</bean>

注入类型

字面量：

null值：

<!--null值-->
<property name="address">
    <null/>
</property>

特殊符号：

<!--属性值包含特殊符号-->
<!--方法1：把<>进行转义：&lt; &gt;-->
<!--方法2：把带特殊符号内容写到CDATA-->
<property name="address">
    <value><![CDATA[<<南京>>]]></value>
</property>

外部bean

创建service类和dao类

在service调用dao里的方法

public class UserServiceImpl {
    //创建UserDao类型属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("service add");
        userDao.update();
    }
}

在spring配置文件中进行配置

<!--service和dao对象创建-->
<bean id="userService" class="cc.mousse.service.UserServiceImpl">
    <!--注入userDao对象-->
    <!--name：类里的属性名称-->
    <!--ref：创建userDao对象bean标签的id值-->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="cc.mousse.dao.UserDaoImpl"/>

内部bean

一对多关系：部门和员工

在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

public class Emp {
    private String eName;
    private String gender;
    //员工属于的部门
    private Dept dept;

    public void seteName(String eName) {
        this.eName = eName;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

在spring配置文件中进行配置

<!--内部bean-->
<bean id="emp" class="cc.mousse.bean.Emp">
    <!--普通属性设置-->
    <property name="eName" value="张三"/>
    <property name="gender" value="男"/>
    <!--对象属性设置-->
    <property name="dept">
        <!--嵌套bean-->
        <bean id="dept" class="cc.mousse.bean.Dept">
            <property name="dName" value="人事"/>
        </bean>
    </property>
</bean>

级联bean

写法1：

<!--级联赋值-->
<bean id="emp" class="cc.mousse.bean.Emp">
    <property name="eName" value="张三"/>
    <property name="gender" value="男"/>
    <property name="dept" ref="dept"/>
</bean>
<bean id="dept" class="cc.mousse.bean.Dept">
    <property name="dName" value="人事"/>
</bean>

写法2：

<!--级联赋值-->
<bean id="emp" class="cc.mousse.bean.Emp">
    <property name="eName" value="张三"/>
    <property name="gender" value="男"/>
    <property name="dept" ref="dept"/>
    <!--需在Emp中生成dept的get方法-->
    <property name="dept.dName" value="人事"/>
</bean>
<bean id="dept" class="cc.mousse.bean.Dept">
    <property name="dName" value="人事"/>
</bean>

注入集合

<!--集合类型属性注入-->
<bean id="collectionType" class="cc.mousse.collection.CollectionType">
    <!--数组类型属性注入-->
    <property name="strings">
        <array>
            <value>a</value>
            <value>b</value>
        </array>
    </property>
    <!--List类型属性注入-->
    <property name="stringList">
        <list>
            <value>a</value>
            <value>b</value>
        </list>
    </property>
    <!--Set类型属性注入-->
    <property name="stringSet">
        <set>
            <value>a</value>
            <value>b</value>
        </set>
    </property>
    <!--Map类型属性注入-->
    <property name="stringMap">
        <map>
            <entry key="1" value="a"/>
            <entry key="2" value="b"/>
        </map>
    </property>
</bean>

注入对象

<!--注入对象类型值-->
<bean id="student" class="cc.mousse.collection.Student">
    <property name="courses">
        <list>
            <ref bean="course1"/>
            <ref bean="course2"/>
        </list>
    </property>
</bean>
<!--创建多个course对象-->
<bean id="course1" class="cc.mousse.collection.Course">
    <property name="cName" value="Spring"/>
</bean>
<bean id="course2" class="cc.mousse.collection.Course">
    <property name="cName" value="JavaSE"/>
</bean>

注入提取

<?xml version="1.0" encoding="UTF-8"?>
<!--在Spring配置文件中引入名称空间util-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:util="http://www.springframework.org/schema/util"
       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
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    
    <!--使用util标签完成List集合注入提取-->
    <util:list id="bookList">
        <value>JavaSE</value>
        <value>Spring</value>
    </util:list>

    <!--提取List集合类型属性注入使用-->
    <bean id="book" class="cc.mousse.collection.Book">
        <property name="list" ref="bookList"/>
    </bean>
</beans>

普通bean

在配置文件中定义bean类型就是返回类型

工厂bean

在配置文件定义bean类型可以和返回类型不一样：

创建类，使此类作为工厂bean并实现接口FactoryBean
实现接口里的方法，在实现的方法中定义返回的bean类型

1	`<bean id="myBean" class="cc.mousse.factbean.MyBean"/>`

public class MyBean implements FactoryBean<Course> {
    /**
     * 定义返回bean类型
     * @return
     * @throws Exception
     */
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setcName("JavaSE");
        return course;
    }
}
public class MyBeanTest {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("factbean.xml");
        Course course = context.getBean("myBean", Course.class);
        System.out.println(course);
    }
}

作用域

Spring里可设置创建bean实例是单实例还是多实例，默认单实例对象

设置方法：spring配置文件bean标签里有属性（scope）用于设置单实例还是多实例

scope属性值：
- singleton：默认值，单实例，加载spring配置文件时候就会创建单实例对象
- prototype：多实例，调用getBean方法时创建多实例对象
- request：每次创建的对象会放到requset域中
- session：每次创建的对象会放到session域中

生命周期

从对象创建到对象销毁的过程

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和对其他bean引用（调用set方法）
调用bean的初始化的方法（需要进行配置初始化的方法）
bean可以使用（对象获取到了）
当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法）

1
2
3

<bean id="orders" class="cc.mousse.bean.Orders" init-method="init" destroy-method="destroy">
    <property name="oName" value="phone"/>
</bean>

public class Orders {
    private String oName;

    public Orders() {
        System.out.println("1.执行无参构造创建bean实例");
    }

    public void setoName(String oName) {
        this.oName = oName;
        System.out.println("2.调用set方法设置属性值");
    }

    /**
     * 创建执行的初始化方法
     */
    public void init() {
        System.out.println("3.执行初始化方法");
    }

    /**
     * 创建执行的销毁方法
     */
    public void destroy() {
        System.out.println("5.执行销毁方法");
    }
}

public class OrdersTest {
    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("orders_bean.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("4.获取创建bean实例对象");
        System.out.println(orders);
        //手动销毁bean实例
        ((ClassPathXmlApplicationContext) context).close();
    }
}

bean的后置处理器：

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和对其他bean引用（调用set方法）
把bean实例传递bean后置处理器的方法：postProcessBeforeInitialization
- 需创建类，实现接口BeanPostProcessor，创建后置处理器
调用bean的初始化的方法（需要进行配置初始化的方法）
把bean实例传递bean后置处理器的方法：postProcessAfterInitialization
bean可以使用（对象获取到了）
当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法）

<bean id="orders" class="cc.mousse.bean.Orders" init-method="init" destroy-method="destroy">
    <property name="oName" value="phone"/>
</bean>
<!--配置后置处理器，会对当前配置文件中的所有bean都添加后置处理操作-->
<bean id="myBeanPost" class="cc.mousse.bean.MyBeanPost"/>

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化前执行的方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化后执行的方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

自动装配

根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入

<bean id="emp" class="cc.mousse.autowire.Emp" autowire="byName">
    <!--bean标签属性autowire配置自动装配
        byName：根据属性名称注入
        byType：根据属性类型注入
    -->
</bean>
<bean id="dept" class="cc.mousse.autowire.Dept"/>

外部属性文件

直接配置数据库信息
1. 配置德鲁伊连接池
2. 引入德鲁伊连接池依赖jar包

<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/userDB"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

引入外部属性文件配置数据库连接池

创建外部属性文件，properties格式文件，写数据库信息

prop.driverClass=com.mysql.cj.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDB
prop.userName=root
prop.password=root

把外部properties属性文件引入到sprin 配置文件中

引入context名称空间

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverclass}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
</beans>

基于注解

代码特殊标记，注解作用在类/方法/属性上面，可简化xml配置

格式：@注解名称（属性名称=属性值, 属性名称=属性值..）

Spring针对Bean管理中创建对象提供注解：

@Component：最普通的组件，可以被注入到spring容器进行管理
@Service：作用于业务逻辑层
@Controller：作用于表现层（spring-mvc的注解）
@Repository：作用于持久层
上面四个注解功能是一样的，都可以用来创建bean实例

对象创建：

引入依赖：spring-aop

开启组件扫描：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启组件扫描：
        如果扫描多个包，多个包使用逗号隔开
        扫描包上层目录
    -->
    <context:component-scan base-package="cc.mousse."/>
</beans>

创建类，在类上添加创建对象注解

//注解中value属性值可省略，默认值即为首字母小写的类名
@Service(value = "userService")
public class UserService {
    public void add() {
        System.out.println("service add");
    }
}

组件扫描配置细节：

<!--示例1
    use-default-filters="false"表示不使用默认filter，使用自己配置的filter
    context:include-filter：设置扫描的内容
    只扫描带Controller的注解类
-->
<context:component-scan base-package="cc.mousse" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--示例2
    context:exclude-filter：设置哪些内容不进行扫描
-->
<context:component-scan base-package="cc.mousse" use-default-filters="false">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

属性注入

@Autowired：根据属性类型进行自动装配

把service和dao对象创建，在service和dao类添加创建对象注解
在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解

@Service(value = "userService")
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired
    private UserDao userDao;

    public void add() {
        System.out.println("service add");
        userDao.add();
    }
}

@Qualifier：根据名称进行注入

@Qualifier注解的使用，和上面@Autowired一起使用

@Service(value = "userService")
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired
    @Qualifier(value = "userDaoImpl")
    private UserDao userDao;

    public void add() {
        System.out.println("service add");
        userDao.add();
    }
}

@Repository(value = "userDaoImpl")
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("dao add");
    }
}

@Resource：可根据类型/名称注入

//根据名称注入
@Resource(name = "userDaoImpl")
//根据类型注入
@Resource   
private UserDao userDao;

@Value：注入普通类型属性

1 2	`@Value(value = "abc") private String name;`

完全注解

创建配置类，替代xml配置文件

//作为配置类替代XML配置文件
@Configuration
//开启组件扫描，与<context:component-scan base-package="cc.mousse"/>等价
@ComponentScan(basePackages = {"cc.mousse"})
public class SpringConfig {
}

public class UserServiceTest {
    @Test
    public void test() {
        //加载配置类
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

AOP

面向切面（方面）编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发效率

不通过修改源代码方式，在主干功能里面添加新功能

底层原理

使用动态代理：

有接口情况：使用JDK动态代理
- 创建接口实现类代理对象，增强类的方法
没有接口情况：使用CGLIB动态代理
- 创建子类的代理对象，增强类的方法

动态代理

使用Proxy类里面的newProxyInstance方法方法创建代理对象
- 参数1：类加载器
- 参数2：增强方法所在的类，这个类实现的接口，支持多个接口
- 参数3：实现这个接口InvocationHandler，创建代理对象，写增强的部分

编写JDK动态代理代码

创建接口，定义方法
创建接口实现类，实现方法
使用 Proxy 类创建接口代理对象

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        System.out.println(dao.add(1, 2));
    }
}

//创建代理对象
class UserDaoProxy implements InvocationHandler {
    //把创建的被代理的对象传递进来
    //通过有参构造传递
    private Object o;

    public UserDaoProxy(Object o) {
        this.o = o;
    }

    /**
     * 增强的逻辑
     *
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法前的处理
        System.out.println("方法前执行" + method.getName() + ":传递的参数" + Arrays.toString(args));
        //被增强的方法
        Object res = method.invoke(o, args);
        //方法后的处理
        System.out.println("方法后执行" + o);
        return res;
    }
}

操作术语

连接点：类里可以被增强的方法

切入点：实际被真正增强的方法

通知（增强）：实际增强的逻辑部分

前置通知：@Before
后置通知（返回通知）：@AfterReturning，出现异常后不执行
环绕通知：@Around
异常通知：@AfterThrowing
最终通知：@After，出现异常后仍会执行
执行顺序：
1. aroundBegin
2. before
3. add
4. afterReturning
5. after
6. aroundAfter

切面：把通知应用到切入点的过程

AOP操作

Spring框架一般都是基于AspectJ实现AOP操作：

AspectJ不是Spring组成部分，是独立AOP框架
一般把AspectJ和Spirng框架一起使用，进行AOP操作

需在项目工程里面引入AOP相关依赖

切入点表达式：知道对哪个类里面的哪个方法进行增强

语法结构:

1	`execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]))`

举例：
- 对cc.mousse.dao.BookDao类的add进行增强：
  1
  execution(* cc.mousse.dao.BookDao.add(..))
- 对cc.mousse.dao.BookDao类里面的所有的方法进行增强：
  1
  execution(* com.atguigu.dao.BookDao.* (..))
- 对cc.mousse.dao 包里面所有类及类里面所有方法进行增强：
  1
  execution(* com.atguigu.dao.*.* (..))

AspectJ

基于xml

创建两个类，增强类和被增强类，创建方法
在spring配置文件中创建两个类对象
在spring配置文件中配置切入点

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--创建对象-->
    <bean id="book" class="cc.mousse.xml.Book"/>
    <bean id="bookProxy" class="cc.mousse.xml.BookProxy"/>
    <!--配置AOP增强-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="point" expression="execution(* cc.mousse.xml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--配置增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

基于注解

常用

创建类，在类里面定义方法
创建增强类（编写增强逻辑）
- 在增强类里创建方法，让不同方法代表不同通知类型

进行通知的配置

在spring配置文件中开启注解扫描

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
                           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="cc.mousse"/>
</beans>

使用注解创建User和UserProxy对象

@Component
public class User {
    public void add() {
        System.out.println("add");
    }
}

在增强类上面添加注解@Aspect

@Component
//生成代理对象
@Aspect
public class UserProxy {
    //前置通知
    public void before() {
        System.out.println("before");
    }
}

在spring配置文件中开启生成代理对象

1 2	`<!--开启Aspect生成代理对象--> <aop:aspectj-autoproxy/>`

配置不同类型的通知

在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

@Component
//生成代理对象
@Aspect
public class UserProxy {
    //@Before注解表示为前置通知
    @Before(value = "execution(* cc.mousse.annotation.User.add(..))")
    public void before() {
        System.out.println("before");
    }

    //最终通知：出现异常后仍会执行
    @After(value = "execution(* cc.mousse.annotation.User.add(..))")
    public void after() {
        System.out.println("after");
    }

    //后置通知（返回通知）：出现异常后不执行
    @AfterReturning(value = "execution(* cc.mousse.annotation.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning");
    }

    //异常通知
    @AfterThrowing(value = "execution(* cc.mousse.annotation.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing");
    }

    @Around(value = "execution(* cc.mousse.annotation.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕后");
    }
}

相同的切入点抽取

//相同切入点抽取
@Pointcut(value = "execution(* cc.mousse.annotation.User.add(..))")
public void point() {
}

@Before(value = "point()")
public void before() {
    System.out.println("before");
}

有多个增强类多同一个方法进行增强，设置增强类优先级

在增强类上面添加注解@Order(数字类型值)，数字类型值越小优先级越高

@Component
@Aspect
@Order(2)
public class UserProxy {
}

完全使用注解开发

创建配置类，不需要创建xml配置文件

@Configuration
//组件扫描
@ComponentScan(basePackages = {"cc.mousse"})
//生成代理对象
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class SpringConfig {
}

JdbcTemplate

Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作

配置

引入相关Jar包

在spring配置文件配置数据库连接池

<!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/jdbc_template"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

配置JdbcTemplate对象，注入DataSource

<!--JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource-->
    <property name="dataSource" ref="dataSource"/>
</bean>

创建service类，创建dao类，在dao注入jdbcTemplate对象

1 2	`<!--开启组件扫描--> <context:component-scan base-package="cc.mousse"/>`

@Repository
public class BookDaoImpl implements BookDao {
    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

@Service
public class BookService {
    //注入DAO
    @Autowired
    private BookDao bookDao;
}

增删改

对应数据库创建实体类

编写service和dao：

在dao进行数据库添加操作

调用JdbcTemplate对象里面update方法实现添加操作：jdbcTemplate.update(sql, args)

参数1：sql语句
参数2：可变参数，设置sql语句值

@Repository
public class BookDaoImpl implements BookDao {
    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //添加的方法
    @Override
    public void add(Book book) {
        String sql = "insert into t_book values(?, ?, ?)";
        int i = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getuStatus());
        System.out.println("影响了" + i + "条记录");
    }
}

测试类

@Test
public void addTest() {
    ApplicationContext context = new ClassPathXmlApplicationContext("druid_bean.xml");
    BookService bookService = context.getBean("bookService", BookService.class);
    bookService.addBook(new Book("1", "JavaEE", "A"));
}

查询

返回某个值：jdbcTemplate.queryForObject(sql, requiredType)

参数1：sql语句
参数2：返回类型Class

public int count() {
    String sql = "select count(*) from t_book";
    Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
    if (integer == null) {
        return 0;
    }
    return integer;
}

返回对象：jdbcTemplate.queryForObject(sql, rowMapper, args)

参数1：sql语句
参数2：RowMapper是接口，针对返回不同类型数据，使用这个接口里面实现类完成
数据封装
参数3：sql语句值

public Book queryOne(int id) {
    String sql = "select * from t_book where user_id = ?";
    return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Book.class), id);
}

返回集合：jdbcTemplate.query(sql, rowMapper, args)

参数1：sql语句
参数2：RowMapper是接口，针对返回不同类型数据，使用这个接口里面实现类完成
数据封装
参数3：sql语句值

public List<Book> queryMulti() {
    String sql = "select * from t_book";
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Book.class));
}

批量操作

增删改：batchUpdate(sql, batchArgs)

参数1：sql语句
参数2：List集合，添加多条记录数据

public void batchAdd(List<Object[]> batchArgs) {
    String sql = "insert into t_book values(?, ?, ?)";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

事务管理

事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败

典型场景：银行转账
- lucy转账100元给mary
- lucy少100，mary多100

特性：ACID

原子性
一致性
隔离性
持久性

事务操作

事务添加到JavaEE三层结构里面Service层（业务逻辑层）

在Spring进行事务管理操作：

方式1：编程式事务管理
方式2：声明式事务管理（使用）
- 基于注解方式（使用）
- 基于xml配置文件方式
- 在Spring进行声明式事务管理，底层使用 AOP 原理

Spring事务管理API：PlatformTransactionManager

提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

注解声明式

在spring配置文件配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"/>
</bean>

在spring配置文件，开启事务注解

在spring配置文件引入名称空间：tx

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

开启事务注解

1 2	`<!--开启事务注解--> <tx:annotation-driven transaction-manager="transactionManager"/>`

在service类或service类里的方法上面添加事务注解
- @Transactional，这个注解添加到类上面，也可以添加方法上面
- 如果把这个注解添加类上面，这个类里面所有的方法都添加事务
- 如果把这个注解添加方法上面，为这个方法添加事务

参数配置

在service类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数

propagation：事务传播行为

多事务方法直接进行调用，这个过程中事务是如何进行管理的
REQUIRED：
- 有事务在运行，当前的方法就在这个事务内运行
- 无事务在运行，启动一个新的事务，并在自己的事务内运行
REQUIRED_NEW：必须启动新事务，并在自己的事务内运行
- 若当前存在事务，把当前事务挂起。
SUPPORTS：
- 有事务在运行，当前方法就在这个事务内运行
- 无事务在运行，可以不运行在事务中
NOT_SUPPORTED：当前的方法不应该运行在事务中
- 若有事务在运行，把当前事务挂起
MANDATORY：当前方法必须运行在事务内
- 若没有事务在运行，抛出异常
NEVER：当前方法不应该运行在事务内
- 若有事务在运行，抛出异常
NESTED：
- 有事务在运行，当前的方法在这个事务的嵌套事务内运行
- 无事务在运行，启动一个新的事务，并在自己的事务内运行

ioslation：事务隔离级别

事务有特性成为隔离性，多事务操作之间不会产生影响，不考虑隔离性产生很多问题
- 脏读：一个未提交事务读取到另一个未提交事务的数据
- 不可重复读：一个未提交事务读取到另一提交事务修改数据
- 虚读：一个未提交事务读取到另一提交事务添加数据
通过设置事务隔离级别，解决读问题：
- READ UNCOMMITTED：读未提交
- READ COMMITTED：读已提交，
  - 解决：脏读
- REPEARABLE READ：可重复读
  - 解决：脏读，不可重复读
- SERIALIZABLE：串行化
  - 解决：脏读，不可重读读，幻读

timeout：超时时间

事务需要在一定时间内进行提交，如果不提交进行回滚
默认值是 -1 ，设置时间以秒单位进行计算

readOnly：是否只读

读：查询操作，写:添加修改删除操作
readOnly 默认值 false，表示可以查询，可以添加修改删除操作
设置 readOnly 值是 true，设置成 true 之后，只能查询

rollbackFor：回滚

设置出现哪些异常进行事务回滚

noRollbackFor：不回滚

设置出现哪些异常不进行事务回滚

@Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.REPEATABLE_READ,
        timeout = -1,
        readOnly = false)
public class UserService {
}

XML声明式

配置事务管理器
配置通知
配置切入点和切面

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/tx/spring-aop.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启组件扫描-->
    <context:component-scan base-package="cc.mousse"/>

    <!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/transaction"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--配置通知-->
    <tx:advice id="txAdvice">
        <!--配置事务参数-->
        <tx:attributes>
            <!--指定哪种规则的方法上面添加事务-->
            <!--account*：以account开头的方法上添加事务-->
            <tx:method name="account*" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>

    <!--配置切入点和切面-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="point" expression="execution(* cc.mousse.service.UserService.*(..))"/>
        <!--配置切面-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="point"/>
    </aop:config>
</beans>

完全注解声明式

创建配置类，使用配置类替代xml配置文件

//配置类
@Configuration
//开启扫描
@ComponentScan(basePackages = "cc.mousse")
//开启事务
@EnableTransactionManagement
public class TxConfig {

    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/transaction");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }

    //创建JDBC模版对象
    @Bean
    //在IOC容器中更具类型找到dataSource
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器对象
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

String5新特性

整个Spring5框架的代码基于Java8，运行时兼容JDK9，法在代码库中删除

Spring5.0框架自带了通用的日志封装：Spring5已经移除Log4jConfigListener，官方建议使用Log4j2

整合Log4j2

引入jar包

创建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>

手动生成log

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class UserLogTest {

    private static final Logger log = LoggerFactory.getLogger(UserLogTest.class);

    public static void main(String[] args) {
        log.info("Hello Log4j2");
        log.warn("Hello Log4j2");
    }
}

@Nullable注解

@Nullable注解可以使用在方法上面，属性上面，参数上面，表示方法返回可以为空，属性值可以为空，参数值可以为空

注解用在方法上面，方法返回值可以为空

注解使用在方法参数里面，方法参数可以为空

注解使用在属性上面，属性值可以为空

函数式风格

GenericApplicationContext

@Test
public void testGenericApplicationContext() {
    //创建GenericApplicationContext对象
    GenericApplicationContext context = new GenericApplicationContext();
    //调用context方法注册对象
    context.refresh();
    context.registerBean("user1", User.class, () -> new User());
    //获取Spring注册的对象
    User user = (User) context.getBean("user1");
    System.out.println(user);
}

整合JUnit5

JUnit4

//指定Junit相关版本
@RunWith(SpringJUnit4ClassRunner.class)
//加载配置文件
@ContextConfiguration("classpath:bean.xml")
public class JTest4 {

    @Autowired
    private UserService userService;

    @Test
    public void test1() {
        Account remitter = userService.queryAccountById(1);
        Account receiver = userService.queryAccountById(2);
        BigDecimal amount = new BigDecimal("100");
        userService.transferAccount(remitter,receiver,amount);
    }
}

JUnit5

//@ExtendWith(SpringExtension.class)
//@ContextConfiguration("classpath:bean.xml")
@SpringJUnitConfig(locations = "classpath:bean.xml")
public class JTest5 {

    @Autowired
    private UserService userService;

    @Test
    public void test() {
        Account remitter = userService.queryAccountById(1);
        Account receiver = userService.queryAccountById(2);
        BigDecimal amount = new BigDecimal("100");
        userService.transferAccount(remitter,receiver,amount);
    }
}

Webflux

是Spring5添加新的模块，用于web开发的，功能和SpringMVC类似的，Webflux使用当前一种比较流程响应式编程出现的框架。

使用传统web框架，比如SpringMVC，这些基于Servlet容器，Webflux是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactor的相关API实现的。

异步非阻塞：

异步和同步，非阻塞和阻塞，都是针对对象不一样
异步和同步针对调用者，调用者发送请求，如果等着对方回应之后才去做其他事情就是同步，如果发送请求之后不等着对方回应就去做其他事情就是异步
阻塞和非阻塞针对被调用者，被调用者受到请求之后，做完请求任务之后才给出反馈就是阻塞，收到请求之后马上给出反馈然后再去做事情就是非阻塞

Webflux特点：

非阻塞式：在有限资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程
函数式编程：Spring5框架基于java8，Webflux使用Java8函数式编程方式实现路由请求

比较SpringMVC：

两个框架都可以使用注解方式，都运行在Tomcat等容器中
SpringMVC采用命令式编程，Webflux采用异步响应式编程

响应式编程

响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便

地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。

电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似”=B1+C1”的公

式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。

Java8及其之前版本：提供的观察者模式两个类Observer和Observable

public class ObserverDemo extends Observable {

    public static void main(String[] args) {
        ObserverDemo observer = new ObserverDemo();
        //添加观察者
        observer.addObserver((o, arg) -> {
            System.out.println("发生了变化");
        });
        observer.addObserver((o, arg) -> {
            System.out.println("收到被观察者通知，准备改变");
        });
        //监控数据变化
        observer.setChanged();
        //通知
        observer.notifyObservers();
    }
}

响应式编程（Reactor实现）：

响应式编程操作中，Reactor是满足Reactive规范框架
Reactor有两个核心类，Mono和Flux，这两个类实现接口Publisher，提供丰富操作符：
- Flux对象实现发布者，返回N个元素
- Mono实现发布者，返回0或者1个元素
Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发出三种数据信号:
- 元素值
- 终止信号：用于告诉订阅者数据流结束了
- 错误信号：终止数据流同时把错误信息传递给订阅者
- 错误信号和完成信号都代表终止信号

<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-core</artifactId>
    <version>3.1.5.RELEASE</version>
</dependency>

public static void main(String[] args) {
    //just方法直接声明
    Flux.just(1, 2, 3, 4);
    Mono.just(1);

    //其他的方法
    Integer[] array = {1, 2, 3, 4};
    Flux.fromArray(array);

    List<Integer> list = Arrays.asList(array);
    Flux.fromIterable(list);

    Stream<Integer> stream = list.stream();
    Flux.fromStream(stream);
}

三种信号特点：

错误信号和完成信号都是终止信号，不能共存的
如果没有发送任何元素值，而是直接发送错误或者完成信号，表示是空数据流
如果没有错误信号，没有完成信号，表示是无限数据流

调用just或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流，不订阅什么都不会发生的

1 2	`Flux.just(1, 2, 3, 4).subscribe(System.out::println); Mono.just(1).subscribe(System.out::println);`

操作符：对数据流进行一道道操作，成为操作符，比如工厂流水线

map：元素映射为新元素
flatMap：元素映射为流
- 把每个元素转换流，把转换之后多个流合并大的流

执行流程/核心API

SpringWebflux基于Reactor，默认使用容器是Netty，Netty是高性能的NIO框架，异步非阻塞的框架

Netty
- BIO：阻塞方式
- NIO：非阻塞方式
SpringWebflux执行过程和SpringMVC相似的
- SpringWebflux核心控制器DispatchHandler，实现接口WebHandler
- 接口WebHandler有一个方法
SpringWebflux里面DispatcherHandler，负责请求的处理
- HandlerMapping：请求查询到处理的方法
- HandlerAdapter：真正负责请求处理
- HandlerResultHandler：响应结果处理
SpringWebflux实现函数式编程，接口：
- RouterFunction：路由处理
- HandlerFunction：处理函数

注解编程

和之前SpringMVC使用相似的，只需要把相关依赖配置到项目中，SpringBoot自动配置相关运行容器，默认情况下使用Netty服务器

创建SpringBoot工程，引入Webflux依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-webflux</artifactId>
</dependency>

配置启动端口号
1
server.port=8080

创建包和相关类：

实体类

public class User {

    private String name;
    private String gender;
    private Integer age;

    public User() {
    }

    public User(String name, String gender, Integer age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    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 Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

}

创建接口定义操作的方法

public interface UserService {

    // 根据ID查询用户
    Mono<User> getUserById(int id);

    // 查询所有的用户
    Flux<User> getAllUser();

    // 添加用户
    Mono<Void> saveUserInfo(Mono<User> user);

}

接口实现类

@Service
public class UserServiceImpl implements UserService {

    // 创建Map集合存储数据
    private final Map<Integer, User> users = new HashMap<>();

    public UserServiceImpl() {
        this.users.put(1, new User("Tom", "male", 20));
        this.users.put(2, new User("Jerry", "male", 30));
        this.users.put(3, new User("Marry", "female", 50));
    }

    // 根据ID查询
    @Override
    public Mono<User> getUserById(int id) {
        return Mono.justOrEmpty(this.users.get(id));
    }

    // 查询多个用户
    @Override
    public Flux<User> getAllUser() {
        return Flux.fromIterable(this.users.values());
    }

    // 添加用户
    @Override
    public Mono<Void> saveUserInfo(Mono<User> user) {
        return user.doOnNext(person -> {
            // 向Map集合里放值
            users.put(this.users.size() + 1, person);
        }).thenEmpty(Mono.empty());
    }

}

创建controller

@RestController
public class UserController {

    // 注入Service
    @Autowired
    private UserService userService;

    // ID查询
    @GetMapping("/user/{id}")
    public Mono<User> getUserId(@PathVariable int id) {
        return userService.getUserById(id);
    }

    // 查询所有
    @GetMapping("/user")
    public Flux<User> getUsers() {
        return userService.getAllUser();
    }

    // 添加
    @PostMapping("/saveuser")
    public Mono<Void> saveUser(@RequestBody User user) {
        Mono<User> userMono = Mono.just(user);
        return userService.saveUserInfo(userMono);
    }

}

SpringMVC方式实现，同步阻塞的方式，基于SpringMVC+Servlet+Tomcat

SpringWebflux方式实现，异步非阻塞方式，基于SpringWebflux+Reactor+Netty

函数式编程

在使用函数式编程模型操作时候需要自己初始化服务器

基于函数式编程模型时候，有两个核心接口：

RouterFunction：实现路由功能，请求转发给对应的 handler
HandlerFunction：处理请求生成响应的函数
核心任务定义两个函数式接口的实现并且启动需要的服务器

SpringWebflux请求和响应不再是ServletRequest和ServletResponse，而是ServerRequest和ServerResponse

把注解编程模型工程复制一份，保留entity和service内容

创建Handler（具体实现方法）

public class UserHandler {

    private final UserService userService;

    public UserHandler(UserService userService) {
        this.userService = userService;
    }

    // 根据ID查询
    public Mono<ServerResponse> getUserById(ServerRequest request) {
        // 获取ID值
        int userId = Integer.parseInt(request.pathVariable("id"));
        // 空值处理
        Mono<ServerResponse> notFound = ServerResponse.notFound().build();
        // 调用Service方法得到数据
        Mono<User> userMono = this.userService.getUserById(userId);
        // 把userMono进行转换返回
        // shyingReactor操作符：flatmap
        return userMono.flatMap(person -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(fromObject(person))).switchIfEmpty(notFound);
    }

    // 查询所有
    public Mono<ServerResponse> getAllUsers(ServerRequest serverRequest) {
        // 调用Service得到结果
        Flux<User> users = this.userService.getAllUser();
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users, User.class);
    }

    // 添加
    public Mono<ServerResponse> saveUser(ServerRequest request) {
        // 得到User对象
        Mono<User> userMono = request.bodyToMono(User.class);
        return ServerResponse.ok().build(this.userService.saveUserInfo(userMono));
    }

}

初始化服务器，编写Router

创建路由的方法

public RouterFunction<ServerResponse> routingFunction() {
        // 创建handler对象
        UserService userService = new UserServiceImpl();
        UserHandler handler = new UserHandler(userService);
        // 设置路由
        return RouterFunctions.route(GET("/users/{id}").and(accept(APPLICATION_JSON)), handler::getUserById).andRoute(GET("/users").and(accept(APPLICATION_JSON)), handler::getAllUsers);
}

创建服务器完成适配

public void createReactorServer() {
    //路由和handler适配
    RouterFunction<ServerResponse> route = routingFunction();
    HttpHandler httpHandler = toHttpHandler(route);
    ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
    //创建服务器
    HttpServer httpServer = HttpServer.create();
    httpServer.handle(adapter).bindNow();
}

最终调用

public static void main(String[] args) throws Exception {
    Server server = new Server();
    server.createReactorServer();
    System.out.println("enter to exit");
    System.in.read();
}

使用WebClient调用

public class Client {

    public static void main(String[] args) {
        // 调用服务器地址
        WebClient webClient = WebClient.create("http://127.0.0.1:5794");
        // 根据id查询
        String id = "1";
        User userresult = webClient.get().uri("/users/{id}", id).accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(User.class).block();
        System.out.println(userresult.getName());
        // 查询所有
        Flux<User> results = webClient.get().uri("/users").accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);
        results.map(stu -> stu.getName());
    }

}

后端

Spring

http://docs.mousse.cc/Spring/

作者

Mocha Mousse

发布于

2025年5月26日

许可协议

Zookeeper 上一篇

SpringBoot 下一篇