Spring

ICETICE

已于 2022-02-12 09:06:42 修改

阅读量392

点赞数

文章标签： spring

于 2021-12-29 12:59:22 首次发布

本文链接：https://blog.youkuaiyun.com/m0_61922004/article/details/122210252

版权

一、框架概述

1. Spring 是轻量级的开源的 JavaEE 框架

2. Spring 可以解决企业应用开发的复杂性

3. Spring 有两个核心部分：IOC 和 Aop

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

4. Spring 特点

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

5. 入门案例

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


import com.atguigu.spring.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5 {
    @Test
    public void testadd(){
        //1.加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //2. 获取配置创建的对象
        User user = context.getBean("user", User.class);

        System.out.println(user);
        user.add();
    }
}

二、IOC

不需要你再new对象了！

2.1 什么是IOC

控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理
使用 IOC 目的：为了耦合度降低

2.2 IOC 底层原理：xml 解析、工厂模式、反射

2.3 底层图解

2.4 IOC（BeanFactory 接口）

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

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

（1）BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用 * 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象（<bean>中加上lazy-init="true"）。

（2）ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用 * 加载配置文件时候就会把在配置文件对象进行创建。

3. ApplicationContext 接口实现类

2.5 IOC 操作 Bean 管理

2.5.1 什么是 Bean 管理

Bean 管理指的是两个操作：

Spring 创建对象
Spring 注入属性

Bean 管理操作有两种方式：

基于 xml 配置文件方式实现
基于注解方式实现

2.5.2 IOC 操作 Bean 管理（基于 xml 方式）

1. 基于 xml 方式创建对象

    <!--配置User类对象创建-->
    <bean id="user" class="com.atguigu.spring.User"></bean>

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

2. 基于 xml 方式注入属性

DI：依赖注入，就是注入属性（Dependency Injection是IOC中一种具体实现，表示依赖注入）

3. 第一种注入方式：使用 set 方法进行注入

（1）创建类，定义属性和对应的 set 方法

/**
 * 演示使用set方法进行注入属性
 */
public class Book {
    //创建属性
    private String bname;
    private String bauthor;
    private String address;
    //创建属性对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }
    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

（2）在 spring 配置文件配置对象创建，配置属性注入

<!--set方法注入属性-->
<bean id="book" class="com.atguigu.spring.Book">
    <!-- 在bean标签内部使用property完成属性注入-->
    <property name="bname" value="《百年孤独》"></property>
    <property name="bauthor" value="马尔克斯"></property>
    <property name="address" value="西班牙"></property>
</bean>

4. 第二种注入方式：使用有参数构造进行注入

（1）创建类，定义属性，创建属性对应有参数构造方法

/**
 * 使用有参数构造注入
 */
public class Orders {
    //属性
    private String oname;
    private String address;
    //有参数构造
    public Orders(String oname,String address) {
        this.oname = oname;
        this.address = address;
    }
}

（2）在 spring 配置文件中进行配置

    <!--3. 有参数构造注入属性-->
    <bean id="orders" class="com.atguigu.spring.Orders">
        <constructor-arg name="oname" value="china"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>

5. p 名称空间注入（了解）

使用 p 名称空间注入，可以简化基于 xml 配置方式

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

第二步进行属性注入，在 bean 标签里面进行操作

2.5.3 IOC操作Bean管理（xml注入其他类型属性）

1. 字面量

（1）空值（直接填value值，输出为空；写<null/>，输出为null）

（2）属性值包含特殊符号

1）把<>进行转义< >

2 ）把带特殊符号内容写到 CDATA

2. 注入属性——外部bean

（1）创建两个类 service 类和 dao 类

（2）在 service 调用 dao 里面的方法

（3）在 spring 配置文件中进行配置

public class UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

    <!--1. 创建service和dao对象-->
    <bean id="userService" class="com.atguigu.spring.service.UserService">
    <!--2. set注入     注入UserDao对象
            name：类里面属性名称
            id: 创建UserDao对象bean标签的id值-->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>
    <bean id="userDaoImpl" class="com.atguigu.spring.dao.UserDaoImpl"></bean>

3. 注入属性——内部 bean

（1）一对多关系：部门和员工

一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多。

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

//部门类
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

//员工类
public class Emp {
    private String ename;
    private String gender;
    //员工属于某一个部门，使用对象形式表示
    private Dept dept;

    //生成dept的get方法
    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }

    public void add() {
        System.out.println(ename+"::"+gender+"::"+dept);
    }
}

（3）在 spring 配置文件中进行配置

<!--内部bean-->
    <bean id="emp" class="com.atguigu.spring.bean.Emp">
<!--设置两个普通属性-->
        <property name="ename" value="zt"></property>
        <property name="gender" value="女"></property>
<!--设置对象类型属性-->
        <property name="dept">
            <bean id="dept" class="com.atguigu.spring.bean.Dept">
                <property name="dname" value="艺术部"></property>
            </bean>
        </property>
    </bean>

4. 注入属性——级联赋值

第一种写法

<!--级联赋值-->
    <bean id="emp" class="com.atguigu.spring.bean.Emp">
<!--设置两个普通属性-->
        <property name="ename" value="zt"></property>
        <property name="gender" value="女"></property>
<!--级联赋值-->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.atguigu.spring.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

第二种写法

2.5.4 IOC操作Bean管理（xml 注入集合属性）

1. 注入数组类型的属性

2. 注入List集合类型属性

3. 注入Map集合类型属性

public class Stu {
    //1 数组类型属性
    private String[] courses;
    //2 list集合类型属性
    private List<String> list;
    //3 map集合类型属性
    private Map<String,String> maps;
    //4 set集合类型属性
    private Set<String> sets;
    
    
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void test() {
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
    }
}

    <!-- 1.集合类型属性注入-->
    <bean id="stu" class="com.atguigu.spring.collectiontype.Stu">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>数据库</value>
            </array>
        </property>
        <!--List类型属性注入-->
        <property name="list">
            <list>
                <value>list1</value>
                <value>list1</value>
            </list>
        </property>
        <!--Map类型属性注入-->
        <property name="maps">
            <map>
                <entry key="key1" value="value1"></entry>
                <entry key="key2" value="value2"></entry>
            </map>
        </property>
        <!--Set类型属性注入-->
        <property name="sets">
            <set>
                <value>set1</value>
                <value>set2</value>
            </set>
        </property>
    </bean>

4. 在集合里面设置对象类型的值

<!--创建多个course对象-->
    <bean id="course1" class="com.atguigu.spring.collectiontype.Course">
        <property name="cname" value="Spring5"></property>
    </bean>
    <bean id="course2" class="com.atguigu.spring.collectiontype.Course">
        <property name="cname" value="Mybatis"></property>
    </bean>

5. 把集合注入部分提取出来

（1）在Spring配置文件中引入名称空间 util

（2）使用util标签完成list集合注入提取

<?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"
       xmlns:util="http://www.springframework.org/schema/util"
       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">

<!--    提取list集合类型属性注入-->
    <util:list id="bookList">
<!--   如果List的是对象类型就用     <ref bean=""></ref>-->
        <value>《百年孤独》</value>
        <value>《月落荒寺》</value>
        <value>《人生海海》</value>
    </util:list>

<!--    2. 提取出List后使用-->
    <bean id="book" class="com.atguigu.spring.collectiontype.Book">
        <property name="list" ref="bookList"></property>
    </bean>

</beans>

2.5.5 IOC 操作 Bean 管理（FactoryBean）

1. Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

2. 普通 bean：在配置文件中定义 bean 类型就是返回类型

3. 工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样（Spring内置）

第一步创建类，让这个类作为工厂 bean，实现接口 FactoryBean

第二步实现接口里面的方法，在实现的方法中定义返回的 bean 类型

public class MyBean implements FactoryBean<Course> {

    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}



//测试
    @Test
    public void test3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Course myBean = context.getBean("myBean", Course.class);
        System.out.println(myBean);
    }

<bean id="myBean" class="com.atguigu.spring.factorybean.MyBean"></bean>

2.5.6 IOC 操作 Bean 管理（bean 作用域）

1. 在 Spring 里面，可以设置创建 bean 实例是单实例还是多实例

2. 在 Spring 里面，默认情况下，bean 是单实例对象

3. 设置单实例或者多实例

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

（2）scope 属性值

第一个值：默认为singleton，表示是单实例对象

第二个值：prototype，表示是多实例对象

（3）singleton 和 prototype 区别（还有request和session，创建对象后放入其作用范围）

第一 singleton 单实例，prototype 多实例

第二

设置 scope 值是 singleton ，加载 spring 配置文件时候就会创建单实例对象（IOC容器启动时会调用方法创建对象放到IOC容器中，以后每次获取都是直接从容器中拿【map.get()】，所以是单实例）；
设置 scope 值是 prototype ，不是在加载 spring 配置文件时候创建对象，而是在在调用 getBean 方法时候创建多实例对象（IOC容器启动不会调用方法创建对象，每次获取的时候才会调用方法创建对象）。

2.5.7 IOC 操作 Bean 管理（bean 生命周期）

1. 生命周期

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

2. bean 生命周期

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

3. 演示 bean 生命周期

public class Orders {

    //无参数构造
    public Orders() {
        System.out.println("第一步 执行无参数构造创建bean实例");
    }

    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    //自己创建执行的初始化的方法
    public void initMethod() {
        System.out.println("第三步 执行初始化的方法");
    }

    //自己创建执行的销毁的方法
    public void destroyMethod() {
        System.out.println("第五步 执行销毁的方法");
    }
}

<!-- init-method和destroy-method设置初始化和销毁方法-->
<bean id="orders" class="com.atguigu.spring.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="phone"></property>
</bean>

4. bean 的后置处理器，bean 生命周期有七步

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

5. 演示添加后置处理器效果

（1）创建类，实现接口 BeanPostProcessor，创建后置处理器

public class MyBeanPost 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;
    }
}

2.5.8 IOC 操作 Bean 管理（xml 自动装配）

1. 什么是自动装配

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

2. 演示自动装配过程

（1）根据属性名称自动注入

<!--    实现自动装配   autowire
            byName：根据属性名称注入  注入bean的id值和类属性名称要一样
            byType:根据属性类型注入
            -->
    <bean id="emp" class="com.atguigu.spring.autowire.Emp" autowire="byName">
<!--        <property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="com.atguigu.spring.autowire.Dept"></bean>

（2）根据属性类型自动注入

2.5.9 IOC 操作 Bean 管理(外部属性文件)

1. 直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池依赖 jar 包

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

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

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

（2）把外部 properties 属性文件引入到 spring 配置文件中

* 引入 context 名称空间

在 spring 配置文件使用标签引入外部属性文件

<!--    引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!-- 获取properties文件内容，根据key获取，使用spring表达式获取 -->
        <property name="driverClassName" value="${prop.driverClass}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.userName}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>

2.5.10 IOC 操作 Bean 管理(基于注解方式)

1. 什么是注解

（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值..)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

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

（1）@Component

（2）@Service （一般用在业务逻辑层）

（3）@Controller （一般用于web层）

（4）@Repository （一般用于dao层或者叫持久层）

* 上面四个注解功能是一样的，都可以用来创建 bean 实例

3. 基于注解方式实现对象创建

第一步：引入依赖

第二步：开启组件扫描

    <!--开启组件扫描
        1  扫描多个包，多个包之前用逗号隔开
        2  扫描包的上层目录
    -->
    <context:component-scan base-package="com.atguigu"></context:component-scan>

第三步创建类，在类上面添加创建对象注解

//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
@Component(value = "userService") //<bean id="userService" class=".."/>
public class UserService {
    public void add() {
    System.out.println("service add.......");
}

4. 开启组件扫描细节配置

    <!--示例 1
    use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
    context:include-filter ，设置扫描哪些内容
      -->
    <context:component-scan base-package="com.atguigu" 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="com.atguigu">
        <context:exclude-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

5. 基于注解方式实现属性注入

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

第一步把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

第二步在 service 注入dao对象，在 service 类添加dao类型属性，在属性上面使用注解

@Service
public class UserService {
    //定义 dao 类型属性
    //不需要添加 set 方法
    //添加注入属性注解
    @Autowired 
    private UserDao userDao;
    public void add() {
        System.out.println("service add.......");
        userDao.add();
    }
}

（2）@Qualifier：根据名称进行注入

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

    //定义dao类型属性
    //(不需要添加set方法)
    //添加注入属性注解
    @Autowired  //根据类型进行注入
    @Qualifier(value = "userDaoImpl1") //根据名称进行注入
    private UserDao userDao;

（3）@Resource：可以根据类型注入，可以根据名称注入（jdk11及以上移除了javax扩展，不能使用该注解）

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

（4）@Value：注入普通类型属性

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

6. 完全注解开发

（1）创建配置类，替代 xml 配置文件

@Configuration  //作为配置类，替代之前xml配置文件
@ComponentScan(basePackages = {"com.atguigu"}) //扫描包
public class SpringConfig {
    
}

（2）编写测试类

三、AOP

3.1 什么是AOP

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

2. 通俗描述：不修改源代码的基础上，在主干功能里面添加新功能

3. 使用登录例子说明 AOP

3.2 AOP底层原理

1. AOP 底层使用动态代理

（1）有两种情况动态代理

第一种：有接口情况，使用 JDK 动态代理

⚫ 创建接口实现类代理对象，增强类的方法

第二种：没有接口的情况，使用CGLIB动态代理

3.3 JDK动态代理

3.3.1 使用 Proxy 类里面的方法创建代理对象

java.lang.reflect.Proxy Class Proxy

调用newProxyInstance方法

//返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序
static Object    newProxyInstance(ClassLoader loader, 类<?>[ ] interfaces, InvocationHandler h)

ClassLoader：类加载器

类<?>[ ] ：增强方法所在的类，这个类实现的接口

InvocationHandler：实现接口InvocationHandler，创建代理对象，实现增强的方法

3.3.2 代码实现

1. 创建接口，定义方法

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);

}

2. 创建接口实现类，实现方法

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

3. 使用Proxy类创建接口代理对象

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};
        //第三个参数使用匿名内部类方法
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            @Override
//            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
//                return null;
//            }
//        });
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        //相当于UserDao userDao = new UserDaoImpl()，只不过后面new的是代理对象。【强转类型必须是接口类型】
        UserDao userDao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDaoImpl));
        System.out.println(userDao.add(1,2));
        System.out.println(userDao.update("周涛真好看！"));
    }
}

//创建代理对象
class UserDaoProxy implements InvocationHandler{
    //1  创建的是谁的代理对象，就要把谁传过来（也就是【把被代理对象传进来】,从而获取被代理对象的所有内容）
    //有参数构造传递
    private Object obj;
    public UserDaoProxy(Object obj){//这里的Object也就是UserDaoImpl，Object更通用
        this.obj = obj;
    }

    //增强的逻辑
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        //方法之前
        System.out.println("方法执行之前……"+method.getName()+":传递的参数："+ Arrays.toString(objects));
        //被增强的方法执行
        Object res = method.invoke(obj, objects);//使用反射：执行被代理对象的方法，被代理对象就是obj
        //方法之后
        System.out.println("方法执行之后……"+obj);
        return res;
    }
}

3.4 AOP术语

1. 连接点：类里面哪些方法可以被增强，这些方法称为连接点。

2. 切入点：类里面实际真正被增强的方法，称为切入点。

3. 通知（增强）：实际增强的逻辑部分称为通知。通知有多种类型：

前置通知 @Before
后置通知 @AfterReturning 有异常就不执行
环绕通知 @Around
异常通知 @AfterThrowing
最终通知 @After 有没有异常都执行

4. 切面：是动作，把通知应用到切入点的过程。

3.5 Spring实现AOP

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

3.5.1 什么是AspectJ

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

3.5.2 基于AspectJ实现AOP操作

1. 基于xml配置文件

2. 基于注解方式（一般都使用注解，方便）

3.5.3 引入依赖

3.5.4 切入点表达式

1. 切入点表达式的作用：知道要对哪个类里的哪个方法进行增强。

2. 语法结构：execution([权限修饰符][返回类型][方法名称]([参数列表]))

例1：对com.atguigu.dao.BookDao类里面的add方法进行增强

execution(* com.atguigu.dao.BookDao.add (..))

【修饰符可以省略，返回值可以用通配符*表示】

例2：对com.atguigu.dao.BookDao类里面的所有方法进行增强

execution(* com.atguigu.dao.BookDao.* (..))

例2：对com.atguigu.dao包里面的所有类里面的所有方法进行增强

execution(* com.atguigu.dao.*.* (..))

3.6 AOP 操作（AspectJ 注解）

3.6.1 创建被增强类

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

3.6.2 创建增强类（编写增强）

在增强类中创建方法，让不同方法代表不同通知类型

@Component
@Aspect //生成一个代理对象
public class UserProxy {//增强类
    //前置通知 @Before表示前置通知
    @Before(value = "execution(* com.atguigu.spring.aopanno.User.add(..))")
    public void before(){
        System.out.println("before……");
    }

    //最终通知 方法执行之后执行
    @After(value = "execution(* com.atguigu.spring.aopanno.User.add(..))")
    public void after(){
        System.out.println("after……");
    }

    // 后置通知（返回通知） 方法执行返回结果之后执行
    @AfterReturning(value = "execution(* com.atguigu.spring.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning……");
    }

    //异常通知
    @AfterThrowing(value = "execution(* com.atguigu.spring.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing……");
    }

    //环绕通知
    @Around(value = "execution(* com.atguigu.spring.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前……");
        //被增强方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后……");
    }
}

3.6.3 进行通知配置

1. 在Spring配置文件中添加新的命名空间：context和aop，并开启配置扫描

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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.atguigu.spring.aopanno"></context:component-scan>
</beans>

2. 使用注解创建User和UserProxy对象

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

4. 在Spring配置文件中开启生成代理对象

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

3.6.4 配置不同类型的通知

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

@Component
@Aspect //生成一个代理对象
public class UserProxy {//增强类
    //前置通知 @Before表示前置通知
    @Before(value = "execution(* com.atguigu.spring.aopanno.User.add(..))")
    public void before(){
        System.out.println("before……");
    }
}

3.6.5 公共切入点抽取

3.6.6 多个增强类对同一个方法进行增强

设置增强类的优先级。

1. 在增强类上面添加一个注解 @Order（数字类型值），值越小优先级越高。

3.6.7 完全使用注解开发

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

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = {"com.atguigu"})
//开启Aspect生成代理对象，proxyTargetClass默认为true。该注解默认为false，不写默认为false
@EnableAspectJAutoProxy(proxyTargetClass = true)

public class ConfigAop {
}

3.7 AOP操作（AspectJ配置文件）（了解）

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

    <!--创建对象-->
    <bean id="book" class="com.atguigu.spring.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.atguigu.spring.aopxml.BookProxy"></bean>

    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.atguigu.spring.aopxml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>

四、JdbcTemplate

4.1 什么是 JdbcTemplate

JdbcTemplate是 Spring 框架对 JDBC 进行封装，从而方便实现对数据库进行操作。

4.2 准备工作

1. 引入相关jar

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

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql//localhost:3306/user_db"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>

3. 配置JdbcTemplate对象，注入DataSource

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

4. 创建service类和dao类，在dao中注入JABCTemplate对象

（1）配置文件中配置

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

（2）创建相关类并注入对象

public interface BookDao {
}


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

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


import com.atguigu.spring.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

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

4.3 JdbcTemplate操作数据库

4.3.1 添加

1. 创建实体类

2. 编写service和dao

（1）. 在 dao 进行数据库添加操作

（2）. 调用 JdbcTemplate 对象里面 update（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(?,?,?)";
        Object[] args = {book.getUserId(), book.getUserName(), book.getuStatus()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }
}

（3）测试

4.3.2 修改和删除

    @Override
    public void updateBook(Book book) {
        String sql = "update t_book set username=?,ustatus=? where user_id=?";
        Object[] args = {book.getUserName(), book.getuStatus(),book.getUserId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    @Override
    public void deleteBook(int id) {
        String sql = "delete from t_book where user_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

4.3.3 查询：返回某个值

1. 查询表里面有多少条记录，返回是某个值

2 .使用 JdbcTemplate 中的方法queryForObject（sql,返回值类型class）实现查询返回某个值代码

    @Override
    public int selectCount() {
        String sql = "select count(*) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count ;
    }

4.3.4 查询：返回对象

1. 场景：查询图书详情

2. JdbcTemplate 类中的方法queryForObject（sql，数据封装，sql?参数）实现查询返回对象

RowMapper：接口。针对不同类型数据，使用其实现类完成数据封装

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

4.3.5 查询：返回集合

1. 场景：查询图书列表分页…

2. 调用 JdbcTemplate 中的方法query（sql，数据封装，sql参数值，）实现查询返回集合

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

4.4 JdbcTemplate批量操作数据库

操作表里面多条记录

4.4.1 批量添加操作

第一个参数：sql 语句

第二个参数：List 集合，添加多条记录数据

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

    @Test
    public void testJdbcTemplateBatchAdd(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        BookService bookService = context.getBean("bookService", BookService.class);
        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {3,"《秦腔》","已售出"};
        Object[] o2 = {4,"《数值分析》","未售出"};
        Object[] o3 = {5,"《深入浅出深度学习》","已售出"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchAdd(batchArgs);
    }

4.4.2 批量修改和删除操作

只有sql语句不同，调用方法及其他都与批量添加相同，不再赘述。

五、事务

5.1 什么是事务

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

2. 典型场景：银行转账

5.2 四大特性（ACID）

原子性 、一致性（事务提交前后数据完整性和状态保持一致）、隔离性、持久性

5.3 环境搭建

1. 创建数据库表

2. 创建service和dao，完成对象创建和关系注入

service中注入dao，dao中注入JdbcTemplate，JdbcTemplate中注入DataSource

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
}


@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
}


public interface UserDao {
}

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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.atguigu.spring"></context:component-scan>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/user_db?useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=GMT"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <!--JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource  set方法注入-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

3. 在dao中创建两个方法，service中调用

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void reduceMoney() {
        String sql = "update t_account set money=money-? where username=?";
        jdbcTemplate.update(sql,100,"lucy");
    }

    @Override
    public void addMoney() {
        String sql = "update t_account set money=money+? where username=?";
        jdbcTemplate.update(sql,100,"mary");
    }
}


@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    public void accountMoney(){
        //lucy 少 100
        userDao.reduceMoney();
        //mary 多 100
        userDao.addMoney();
    }
}

若出现异常，如lucy少100后，断电、断网等异常情况发生时，会导致lucy的钱少了，mary的钱却没有多！

5.4 Spring事务管理介绍

1. 事务一般添加到JavaEE三层结构的Service层（业务逻辑层）

2. Spring进行事务管理操作有两种方式

（1）编程式事务管理

（2）声明式事务管理（一般都使用声明式）

3. 声明式事务管理

（1）基于注解方式（一般都使用注解方式）

（2）基于xml配置文件方式

4. 在Spring中进行事务管理，底层使用AOP

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

5.5 注解声明式事务管理

1. 在spring配置文件中配置事务管理器

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

2. 在spring配置文件中开启事务注解

    <!--开启事务注解-->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager">
    </tx:annotation-driven>

3. 在service类上（或者service类里面的方法上面）添加事务注解

@Transactional 添加到类上或者方法上都可以

添加到类上面表示为这个类里面所有方法都添加事务
添加到方法上面表示只为这个方法添加事务

@Service
@Transactional(propagation = Propagation.REQUIRED)
public class UserService {

5.6 声明式事务管理参数配置

1. @Transactional注解的相关参数

2. propagation：事务传播行为

在多事务方法之间的调用过程中，事务是如何进行管理的。

（当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行）

Spring框架中事务传播行为有7种：

（上图表示add和update两个方法都有事务的情况下！）

@Service
@Transactional(propagation = Propagation.REQUIRED)
public class UserService {

3. isolation：事务隔离级别

多事务操作之间不会相互产生影响。

问题：

（1）脏读：一个事务读取到另一个未提交事务的数据

（2）不可重复读：一个事务读取到另一提交事务修改的数据（修改前后读取数据不同）

（3）幻读：一个事务读取到另一提交事务添加的数据

解决：设置隔离级别

@Service
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)
public class UserService {

4. timeout：超时时间

事务需要在一定的时间内提交，否则会进行回滚。默认值为-1（永不超时），设置单位为秒。

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

5. readonly：是否可读

读：查询操作。默认值为false，表示既可以查询，也可以添加、修改和删除（写）操作。

readOnly = true时，只能进行读操作。

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

6. rollbackFor：回滚

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

7. norollbackFor：不回滚

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

5.7 XML声明式事务管理

在Spring配置文件中配置：

第一步：配置事务管理器

第二步：配置通知

第三步：配置切入点和切面

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

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/user_db?useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=GMT"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <!--JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource  set方法注入-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--1  创建事务管理器-->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--2  配置通知-->
    <tx:advice id="txadvice" transaction-manager="dataSourceTransactionManager">
        <!--配置事务一些参数-->
        <tx:attributes>
            <!--指定在哪种方法上添加事务-->
            <tx:method name="accountMoney" propagation="REQUIRED" />
            <!--<tx:method name="account*"/>    account*表示account开头的所有方法-->
        </tx:attributes>
    </tx:advice>
    <!--3  配置切入点和切面-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pt" expression="execution(* com.atguigu.spring.service.UserService.*(..))"/>
        <!--配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor>
    </aop:config>

5.8 完全注解声明式事务开发

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.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration //配置类
@ComponentScan(basePackages = "com.atguigu") //组件扫描
@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/user_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        return dataSource;
    }

    //创建 JdbcTemplate 对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {//IOC容器中已经存在了DataSource对象
        //到 ioc 容器中根据类型找到 dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入 dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}