Spring学习

一 . 核心概念

  • IOC（Inversion of Control）控制反转

    使用对象时，由主动new产生对象转换为由 外部 提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。通俗的讲就是 “将new对象的权利交给Spring，我们从Spring中获取对象使用即可”

  • Spring技术对IOC思想进行了实现

    • Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的 外部
    • IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IOC容器中统称为Bean

  • DI（Dependency Injection）依赖注入

    • 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入。

  • 目标：充分解耦

    • 使用IoC容器管理bean（IOC)
    • 在IoC容器内将有依赖关系的bean进行关系绑定（DI）

  • 最终效果

    • 使用对象时不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

二 . 初步实现

将被管理的对象交给IOC容器 , 然后在容器中建立bean与bean之间的依赖关系(DI)

结构

1 . 创建接口和实现类

UserDao 的接口和实现类

public interface UserDaoApi {
    public void save();
}


public class UserDao implements UserDaoApi {

    public void save(){
        System.out.println("dao save");

    }
}

USerService 的接口和实现类

public interface UserServiceApi {
    public void save();
}


public class UserService implements UserServiceApi {
    private UserDao dao;
    public void save(){
        System.out.println("service save");
        dao.save();
    }

    public void setDao(UserDao dao) {
        this.dao = dao;
    }
}

2 . 创建配置文件

applicationContext.xml , 在 resources 文件夹下

<bean id="userService" class="com.service.UserService">
        <!--配置server与dao的关系
            property标签：表示配置当前bean的属性
            name属性：表示配置哪一个具体的属性
            ref属性：表示参照哪一个bean-->
        <property name="dao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.dao.UserDao"></bean>

三 . Bean基础

1 . 别名配置

name来配置别名可以用 " 空格 , ; "来分隔

<bean id="userDao" name="test 111,a;b" class="com.dao.UserDao"></bean>

2 . 作用范围

因为 bean 的默认为单例

UserService Service1= (UserService)ctx.getBean("userService");
UserService Service2= (UserService)ctx.getBean("userService");
System.out.println(service1);
System.out.println(service2);
//如此打印出来的 service1 service2 这两个对象的地址是一样的

当给 bean 添加 scope 属性后

<!--
scope 的默认属性为singleton
在设置prototype后会在多次使用后创建不同的对象
-->
<bean id="userDao" class="com.dao.UserDao" scope="prototype"></bean>
scope 还有request、session、application、 websocket ，表示创建出的对象放置在web容器(tomcat)对应的位置。比如：request表示保存到request域中。

四、Bean的实例化

1 . Bean是如何创建的

bean本质上就是对象，创建bean使用构造方法完成

2 . 实例化Bean的三种方式

2.1 . 构造方法方式 (重要)

在创建 bean 时,调用的是对应类的无参构造方法 ,

当被有参构造方法重写后会抛出异常 BeanCreationException

2.2 . 使用静态工厂造bean

处理早期遗留问题 , 知道就好

2.3 . 实例工厂方式

处理早期遗留问题 , 知道就好

五 . Bean生命周期控制

1 . 自定义

  • 提供生命周期控制方法 , 在 Dao 层设置
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }
  • applicationContext.xml声明
<!--
init-method="init" destroy-method="destory"
-->
<bean id="Dao" class="xxx" init-method="init" destroy-method="destory"/>

容器运行在虚拟机中 , 程序执行完 , 虚拟机会直接关闭 , 并不会主动关闭容器 , 需要手动关闭

public static void main( String[] args ) {
        //此处需要使用实现类类型，接口类型没有close方法
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //关闭容器，执行销毁的方法
        ctx.close();
        //或者钩子来关闭容器
        ctx.registerShutdownHook();
    }

ClassPathXmlApplicationContext 这个类继承了 ApplicationContext 的 close 方法

ctx.close() 和 ctx.registerShutdownHook() , 前者暴力,只能放在程序尾部 , 后者任意

2 . Spring内置

在 service 层实现 InitializingBean , DisposableBean 接口 , 并实现对应的方法

public class UserService implements UserServiceApi , InitializingBean, DisposableBean {
    private UserDao dao;

    public void save(){
        System.out.println("service save");
        dao.save();
    }

    public void setDao(UserDao dao) {
        this.dao = dao;
    }

    @Override
    public void destroy() throws Exception {

    }

    @Override
    public void afterPropertiesSet() throws Exception {

    }
}

ctx.close() 或 ctx.registerShutdownHook()

六 . 依赖注入(DI)

1 . 依赖注入的两种方式

1.1 .setter注入

前文用的都是setter注入 , 但前文都是用的引用类型

简单类型注入的方式 , 还是一样创建对应的 set 方法

在对应的 Bean 下

<!-- 
name为简单类型的名称
value为传入的值
-->
<property name="connectNum" value="10"></property>

1.2 .构造器注入

在类中创建有参构造器 , 构造器注入,传递的是形参

public UserService(UserDao dao, int connectNum) {
        this.dao = dao;
        this.connectNum = connectNum;
    }
<bean id="userService" class="com.service.UserService">
        <constructor-arg name="connectNum" value="10"></constructor-arg>
        <constructor-arg name="dao" ref="userDao"></constructor-arg>
</bean>
<bean id="userDao" name="test 111,a;b" class="com.dao.UserDao"></bean>

1.3 . 注入方式选择

  • 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
  • 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入

2 . 依赖自动装配

IOC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配

自动装配方式 :

  • 按类型
  • 按名称
  • 按构造方法

2.1 . 依赖自动装配特征

  • 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  • 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  • 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
  • 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

2.2 . 实现

简单类型用构造器方法或者setter方法

引用类型自动装配 : autowire="byType"

<bean id="userService" class="com.service.UserService" autowire="byType">
        <constructor-arg name="connectNum" value="10"></constructor-arg>
</bean>
<bean id="userDao" name="test 111,a;b" class="com.dao.UserDao"></bean>

3 . 集合注入

public class UserDao implements UserDaoApi {

    private int[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void save(){
        System.out.println("dao save");
    }

    @Override
    public String toString() {
        return "UserDao{" +
                "array=" + Arrays.toString(array) +
                ", list=" + list +
                ", set=" + set +
                ", map=" + map +
                ", properties=" + properties +
                '}';
    }
}

3.1 . 注入数组类型数据

<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>

3.2 . 注入List类型数据

<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>

3.3 . 注入Set类型数据

<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>

3.4 . 注入Map类型数据

<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>

3.5 . 注入Properties类型数据

<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

七 . Spring注解开发

1 . 注解定义Bean对象

xml配置Bean对象有些繁琐，使用注解简化Bean对象的定义

1.1 . 基本使用

在 applicationContext.xml 中开启 Spring 注解包扫描

<context:component-scan base-package="com.dao"/>

在类上使用 @Component 注解定义 Bean

package com.dao;

@Component("dao")
public class UserDao implements UserDaoApi {

    public void save(){
        System.out.println("dao save");
    }
}

1.2 . @Component三个衍生注解

加粗的注解为常用注解

Spring提供@Component注解的三个衍生注解

  • @Controller：用于控制层bean定义
  • @Service：用于业务层bean定义
  • @Repository：用于数据层bean定义

2 . 纯注解开发模式

Java类代替Spring核心配置文件
  • @Configuration注解用于设定当前类为配置类
  • @ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式
@ComponentScan({"com.itheima.service","com.itheima.dao"})
  • 读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象
//加载  配置文件  初始化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

//加载  配置类  初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

2.1 . 代码

定义配置类代替配置文件

在 com 包下创建 config 包 再创建 SpringConfig 类

//声明当前类为Spring配置类
@Configuration
//Spring注解扫描，相当于<context:component-scan base-package="com"/>
@ComponentScan("com")
//设置bean扫描路径，多个路径书写为字符串数组格式
//@ComponentScan({"com.service","com.dao"})
public class SpringConfig {
}

在测试类中加载配置类，获取Bean对象并使用

public static void main(String[] args) {
    //AnnotationConfigApplicationContext加载Spring配置类初始化Spring容器
    ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
    BookDao bookDao = (BookDao) ctx.getBean("UserDao");
    System.out.println(bookDao);
    //按类型获取bean    
    UserService userService = ctx.getBean(UserService.class);
    System.out.println(userService);
}

3 . 注解开发Bean作用范围和生命周期管理

3.1 . bean作用范围注解配置

  • 使用@Scope定义bean作用范围
@Repository("dao")
@Scope("prototype")
public class UserDao implements UserDaoApi {
    public void save(){
        System.out.println("dao save    ");
    }
}

3.2 . bean生命周期注解配置

  • 使用 @PostConstruct 、@PreDestroy 定义bean生命周期
@Repository("dao")
@Scope("prototype")
public class UserDao implements UserDaoApi {
    public void save(){
        System.out.println("dao save    ");
    }

    @PreDestroy
    //销毁前
    public void destroy(){
        System.out.println("destroy service");
    }

    /**
     * 执行后
     */
    @PostConstruct
    public void afterPropertiesSet(){

        System.out.println("init service");
    }
}

注意：@PostConstruct和@PreDestroy注解是jdk中提供的注解，从jdk9开始，jdk中的javax.annotation包被移除了，需要导依赖解决这个问题。

<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>

4 . 注解开发依赖注入

4.1 . 使用@Autowired注解开启自动装配模式

不管是使用配置文件还是配置类，都必须进行对应的 Spring 注解包扫描才可以使用。 @Autowired 默认按照类型自动装配，如果IOC容器中同类的 Bean 有多个，那么默认按照变量名和Bean的名称匹配，建议使用 @Qualifier 注解指定要装配的 Bean 名称

package com.service;

//业务逻辑层
@Service
public class UserService implements UserServiceApi{
    //@Autowired：注入引用类型，自动装配模式，默认按类型装配
    @Autowired
    private UserDao dao;

    public void save(){
        System.out.println("service save    "+UserServiceName);
        dao.save();
    }
    
    @PreDestroy
    //销毁前
    public void destroy(){
        System.out.println("destroy service");
    }

    /**
     * 执行后
     */
    @PostConstruct
    public void afterPropertiesSet(){

        System.out.println("init service");
    }
}

自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据，因此无需提供setter方法

4.2 . 使用@Qualifier注解指定要装配的bean名称

目的：解决IOC容器中同类型Bean有多个装配哪一个的问题
package com.service;

//业务逻辑层

@Service
public class UserService implements UserServiceApi{

    @Autowired
    //@Qualifier注解无法单独使用，必须配合@Autowired注解使用
    @Qualifier("dao")
    private UserDao dao;

    public void save(){
        System.out.println("service save    ");
        dao.save();
    }

    @PreDestroy
    //销毁前
    public void destroy(){
        System.out.println("destroy service");
    }

    /**
     * 执行后
     */
    @PostConstruct
    public void afterPropertiesSet(){

        System.out.println("init service");
    }
}

4.3 . 使用@Value实现简单类型注入

package com.service;

//业务逻辑层
@Service
public class UserService implements UserServiceApi{

    @Autowired
    //@Qualifier注解无法单独使用，必须配合@Autowired注解使用
    @Qualifier("dao")
    private UserDao dao;
    @Value("${name}")
    private String UserServiceName;

    public void save(){
        System.out.println("service save    "+UserServiceName);
        dao.save();
    }

    @PreDestroy
    //销毁前
    public void destroy(){
        System.out.println("destroy service");
    }

    /**
     * 执行后
     */
    @PostConstruct
    public void afterPropertiesSet(){

        System.out.println("init service");
    }
}

以上@Value注解中使用${name}从属性文件中读取name值，那么就需要在配置类或者配置文件中加载属性文件。

在 resources 下 --> 创建 jdbc.properties

name=enter
package com.config;

//声明当前类为Spring配置类
@Configuration
//Spring注解扫描，相当于<context:component-scan base-package="com"/>
@ComponentScan("com")
@PropertySource("classpath:jdbc.properties") //{}当有多个时
public class SpringConfig {
}

八 . 注解开发管理第三方Bean【重点】

需要导入依赖 Druid

<!--
用的人最多
-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

1 . 单独定义配置类

public class JdbcConfig {
    //@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}

2 . 将独立的配置类加入核心配置

2.1 . @Import注解导入式

@Configuration
@ComponentScan("com")
//@Import:导入配置信息
@Import({JdbcConfig.class})
public class SpringConfig {
}

2.2 . @ComponentScan扫描式

@Configuration
@ComponentScan("com")  //只要com.config包扫到了就行，三个包可以合并写成com.itheima
public class SpringConfig {
}

九 . 注解开发为第三方Bean注入资源

1 . 简单类型依赖注入

public class JdbcConfig {
    //1.定义一个方法获得要管理的对象
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/spring_db")
    private String url;
    @Value("root")
    private String userName;
    @Value("root")
    private String password;
    //2.@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}
说明：如果@Value()中使用了EL表达式读取properties属性文件中的内容，那么就需要加载properties属性文件。

2 . 引用类型依赖注入

//Spring会自动从IOC容器中找到BookDao对象赋值给参数bookDao变量，如果没有就会报错。
@Bean 
public DataSource dataSource(UserDao userDao){
    System.out.println(userDao);
    DruidDataSource ds = new DruidDataSource();
    ds.setDriverClassName(driver);
    ds.setUrl(url);
    ds.setUsername(userName);
    ds.setPassword(password);
    return ds;
}
说明：引用类型注入只需要为bean定义方法设置形参即可，容器会根据类型自动装配对象

十 . Spring整合Mybatis和Juint

​ Spring整合Mybatis和Juint

引入的依赖 , 看着删

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.0</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.18</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>

1 . 创建config配置类层

1.1 . config类下JdbcConfig

配置DataSource数据源

package com.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driver);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(userName);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }

}

1.2 . config类下MybatisConfig

MybatisConfig整合mybatis

package com.config;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MybatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setTypeAliasesPackage("com.entity.User");
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }
    //定义bean，返回MapperScannerConfigurer对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.dao");
        return msc;
    }
}

1.3 . config类下SpringConfig

创建SpringConfig主配置类进行包扫描和加载其他配置类

package com.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;

@Configuration
@ComponentScan("com")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

2 . 创建Dao数据访问层

dao基础代码

创建一个接口 , 利用注解省略 mapper.xml 文件

package com.dao;

import com.entity.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;

public interface UserDaoApi {

    @Insert("insert into test(id,userName,userPwd)values(#{id},#{userName},#{userPwd})")
    void Insert(User user);

    @Delete("delete from test where id = #{id} ")
    void delete(Integer id);

    @Update("update test set userName = #{userName} , userPwd = #{userPwd} where id = #{id} ")
    void update(User user);

    @Select("select * from test")
    List<User> findAll();

    @Select("select * from test where id = #{id} ")
    User findById(Integer id);
}

3 . 创建entity实体类层

定义User对象 , 变量与字段一致

package com.entity;

public class User {
    private Integer id;
    private String userName;
    private String UserPwd;

    public User(Integer id, String userName, String userPwd) {
        this.id = id;
        this.userName = userName;
        UserPwd = userPwd;
    }

    public User(Integer id) {
        this.id = id;
    }

    public Integer getUserId() {
        return id;
    }

    public void setUserId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserPwd() {
        return UserPwd;
    }

    public void setUserPwd(String userPwd) {
        UserPwd = userPwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + id +
                ", userName='" + userName + '\'' +
                ", UserPwd='" + UserPwd + '\'' +
                '}';
    }
}

4 . 创建service业务逻辑层

service基础代码

4.1 . UserService

package com.service;

import com.dao.UserDaoApi;
import com.entity.User;
import com.service.Api.UserServiceApi;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService implements UserServiceApi {
    @Autowired
    private UserDaoApi userDao;

    public void insert(User user) {
        userDao.Insert(user);
    }

    public void update(User user){
        userDao.update(user);
    }

    public void delete(Integer id) {
        userDao.delete(id);
    }

    public User findById(Integer id) {
        return userDao.findById(id);
    }

    public List<User> findAll() {
        return userDao.findAll();
    }
}

4.2 . UserServiceApi

创建 API 包 --> UserServiceApi

package com.service.Api;

import com.entity.User;
import java.util.List;

public interface UserServiceApi {

    void insert(User user);

    void delete(Integer id);

    void update(User user);

    List<User> findAll();

    User findById(Integer id);
}

5 . 创建JDBC的properties文件

在 resources 包下

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/atanycosts?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=root

指定时区 , 不然会报时区错误

?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC

6 . Test类

Java整合Juint的两个注解

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)

依赖

<!--junit的依赖至少要是4.12版本-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.1</version>
    <scope>test</scope>
</dependency>
<!--spring整合junit-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
import com.config.SpringConfig;
import com.entity.User;
import com.service.Api.UserServiceApi;
import com.service.UserService;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

//使用Spring整合Junit专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
//加载配置文件或者配置类
@ContextConfiguration(classes = SpringConfig.class)
public class test {
    //支持自动装配注入bean
    @Autowired
    private UserServiceApi userServiceApi;
    @Test
    public void getId(){
        System.out.println(userServiceApi.findAll());
    }

    @Test
    public void test(){
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

        UserService accountService = ctx.getBean(UserService.class);
        User user = new User(null,"111","11");
        accountService.insert(user);
        User ac = accountService.findById(1);
        System.out.println(ac+"\n"+user);
    }
}

十一 . AOP面向切面编程

1 AOP简介

1.1 . AOP简介和作用

  • AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构

    • OOP(Object Oriented Programming)面向对象编程
  • 作用：在不惊动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法源代码的基础上对方法进行功能增强。
  • Spring理念：无入侵式/无侵入式

1.2 . AOP中的核心概念

  • 连接点（JoinPoint）：正在执行的方法，例如：update()、delete()、select()等都是连接点 随便一个方法

  • 切入点（Pointcut）：进行功能增强了的方法，例如:update()、delete()方法，select()方法没有被增强所以不是切入点，但是是连接点。

    • 在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法

      • 一个具体方法：com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
      • 匹配多个方法：所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法

  • 通知类：通知方法所在的类叫做通知类

    • 通知（Advice）：在切入点前后执行的操作，也就是增强的共性功能

      • 在SpringAOP中，功能最终以方法的形式呈现
  • 切面（Aspect）：描述通知与切入点的对应关系，也就是哪些通知方法对应哪些切入点方法。

1.2 . AOP入门案例思路分析

  • 在接口执行前输出当前系统时间
  • 注解

  • 思路分析：

    1. 导入坐标（pom.xml）
    2. 制作连接点方法（原始操作，dao接口与实现类）
    3. 制作共性功能（通知类与通知）
    4. 定义切入点
    5. 绑定切入点与通知关系（切面）

花费一小时解决一个问题 , 还是无意试试

在开启AOP功能时,需要设置 proxyTargetClass = true , 不然会导致Bean找不到

@EnableAspectJAutoProxy(proxyTargetClass = true)
1.2.1 . 导入坐标
<dependencies>
    <!--spring核心依赖，会将spring-aop传递进来-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <!--切入点表达式依赖，目的是找到切入点方法，也就是找到要增强的方法-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>
1.2.2 . 定义接口和实现类

service层和dao层都行

package com.service;

@Service
public class UserService implements UserServiceApi {

    @Autowired
    private UserDaoApi userDao;

    //原有的打印时间方法
    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("AOP测试 save ...");
    }

    //要连接的方法
    public void update1(){
        System.out.println("AOP测试 update ...");
    }
}
1.2.3 . 定义通知类，制作通知方法
//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
package com.aop;

//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
public class aopTest {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
1.2.4 . 定义切入点表达式、配置切面(绑定切入点与通知关系)

相关注解

//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect


//设置切入点，@Pointcut注解要求配置在方法上方
@Pointcut("execution(void com.service.Api.UserServiceApi.update1())")
public void pt(){}

//设置在切入点pt()的前面运行当前操作(前置通知)
@Before("pt()")
public void method(){}
package com.aop;

//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
public class aopTest {
    //设置切入点，@Pointcut注解要求配置在方法上方
    @Pointcut("execution(void com.service.Api.UserServiceApi.update1())")
    public void pt(){}

    //设置在切入点pt()的前面运行当前操作(前置通知)
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
1.2.5 . 在配置类中开启AOP功能
//开启注解开发AOP功能
@EnableAspectJAutoProxy(proxyTargetClass = true)
1.2.6 . Test类
@Test
public void test(){
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = ctx.getBean(UserService.class);
        userService.update1();
}

2 . AOP工作流程

2.1 . AOP工作流程

  1. Spring容器启动
  2. 读取所有切面配置中的切入点

  3. 初始化bean，判定bean对应的类中的方法是否匹配到任意切入点

    • 匹配失败，创建原始对象
    • 匹配成功，创建原始对象（目标对象）的代理对象

  4. 获取bean执行方法

    • 获取的bean是原始对象时，调用方法并执行，完成操作
    • 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

2.2 . AOP核心概念

目标对象（Target）：被代理的对象，也叫原始对象，该对象中的方法没有任何功能增强。
代理对象（Proxy）：代理后生成的对象，由Spring帮我们创建代理对象。

3 . AOP切入点表达式

3.1 . 语法格式

  • 切入点：要进行增强的方法

  • 切入点表达式：要进行增强的方法的描述方式

    • 描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法
    @Pointcut("execution(void com.dao.UserDao.update())")
    • 描述方式二：执行com.dao包下的UserDao类中的无参数update方法
    @Pointcut("execution(void com.dao.UserDao.update())")

  • 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）

    @Pointcut("execution(public User com.dao.UserDao.findById(int))")
    • 动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点
    • 访问修饰符：public，private等，可以省略
    • 返回值：写返回值类型
    • 包名：多级包使用点连接
    • 类/接口名：
    • 方法名：
    • 参数：直接写参数的类型，多个类型用逗号隔开
    • 异常名：方法定义中抛出指定异常，可以省略

3.2 . 通配符

目的：可以使用通配符描述切入点，快速描述。
  • ：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法
execution（public * com.*.UserService.find*(*))
  • .. ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法
execution（public User com..UserService.findById(..))
  • +：专用于匹配子类类型
execution(* *..*Service+.*(..))

4 . AOP通知类型 (重点)

4.1 . AOP通知分类

  • AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置

  • AOP通知共分为5种类型

    • 前置通知 ：在切入点方法执行之前执行
    • 后置通知 ：在切入点方法执行之后执行，无论切入点方法内部是否出现异常，后置通知都会执行。
    • 环绕通知 : 手动调用切入点方法并对其进行增强的通知方式。
    • 返回后通知 ：在切入点方法执行之后执行，如果切入点方法内部出现异常将不会执行。
    • 抛出异常后通知 ：在切入点方法执行之后执行，只有当切入点方法内部出现异常之后才执行。

4.2 . AOP通知详解

4.2.1 . 前置通知
  • 名称：@Before
  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行
//设置切入点，@Pointcut注解要求配置在方法上方
@Pointcut("execution(void com.service.Api.UserServiceApi.update1())")
public void pt(){}

@Before("pt()")
public void before() {
    System.out.println("before advice ...");
}
4.2.2 . 后置通知
  • 名称：@After
  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行
//设置切入点，@Pointcut注解要求配置在方法上方
@Pointcut("execution(void com.service.Api.UserServiceApi.update1())")
public void pt(){}

@After("pt()")
public void after() {
    System.out.println("after advice ...");
}
4.2.3 . 返回后通知
  • 名称：@AfterReturning
  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行
//设置切入点，@Pointcut注解要求配置在方法上方
@Pointcut("execution(void com.service.Api.UserServiceApi.update1())")
public void pt(){}

@AfterReturning("pt()")
public void afterReturning() {
    System.out.println("afterReturning advice ...");
}
4.2.4 . 抛出异常后通知
  • 名称：@AfterThrowing
  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行
//设置切入点，@Pointcut注解要求配置在方法上方
@Pointcut("execution(void com.service.Api.UserServiceApi.update1())")
public void pt(){}

@AfterThrowing("pt()")
public void afterThrowing() {
    System.out.println("afterThrowing advice ...");
}
4.2.5 . 环绕通知
  • 名称：@Around（重点，常用）

  • 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行

    public Object around(ProceedingJoinPoint pjp) throws Throwable {
    //调用pjp.proceed() , 不然连接点的业务会消失
    Object ret = pjp.proceed();
}
//设置切入点，@Pointcut注解要求配置在方法上方
@Pointcut("execution(void com.service.Api.UserServiceApi.update1())")
public void pt(){}

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("around before advice ...");
    Object ret = pjp.proceed();
    System.out.println("around after advice ...");
    return ret;
}

环绕通知注意事项

  1. 环绕通知方法形参必须是ProceedingJoinPoint，表示正在执行的连接点，使用该对象的proceed()方法表示对原始对象方法进行调用，返回值为原始对象方法的返回值。
  2. 环绕通知方法的返回值建议写成Object类型，用于将原始对象方法的返回值进行返回，哪里使用代理对象就返回到哪里。

5 . 通过AOP测试接口耗时

在原本整合Mybatis和Juint的基础上测试

5.1 . Test类

 /**
* 测试获取所有效率
*/
@Test
public void getAll(){
    userServiceApi.findAll();
}

/**
* 测试获取指定效率
*/
@Test
public void getById(){
    userServiceApi.findById(1);
}

//打印结果
万次执行：com.service.UserService.findAll---->3763ms
万次执行：com.service.UserService.findById---->1555ms

5.2 . 通知类

通知所有接口 , 但在Test类中只调用查询接口

@Pointcut("execution(* com.service.Api.UserServiceApi.*(..))")
public void pt(){}

//设置环绕通知，在原始操作的运行前后记录执行时间
@Around("pt()") //本类类名可以省略不写
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
    //获取执行的签名对象
    Signature signature = pjp.getSignature();
    //获取接口/类全限定名
    String className = signature.getDeclaringTypeName();
    //获取方法名
    String methodName = signature.getName();
    //记录开始时间
    long start = System.currentTimeMillis();
    //执行万次操作
    for (int i = 0; i < 10000; i++) {
        pjp.proceed();
    }
    //记录结束时间
    long end = System.currentTimeMillis();
    //打印执行结果
    System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
}

6 . AOP切入点数据获取

6.1 . 获取参数

说明：在前置通知和环绕通知中都可以获取到连接点方法的参数们
  • JoinPoint 对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数
@Before("pt()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
}
  • ProccedJointPoint 是 JoinPoint 的子类
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    Object[] args = pjp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
    Object ret = pjp.proceed();
    return ret;
}

6.2 . 获取返回值

说明：在返回后通知和环绕通知中都可以获取到连接点方法的返回值
  • 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象
@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(String ret) { //变量名要和returning="ret"的属性值一致
    System.out.println("afterReturning advice ..."+ret);
}
  • 环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    // 手动调用连接点方法，返回值就是连接点方法的返回值
    Object ret = pjp.proceed();
    return ret;
}

6.3 . 获取异常

说明：在抛出异常后通知和环绕通知中都可以获取到连接点方法中出现的异常
  • 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象
@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {//变量名要和throwing = "t"的属性值一致
    System.out.println("afterThrowing advice ..."+ t);
}
  • 抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象
@Around("pt()")
public Object around(ProceedingJoinPoint pjp)  {
    Object ret = null;
    //此处需要try...catch处理，catch中捕获到的异常就是连接点方法中抛出的异常
    try {
        ret = pjp.proceed();
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return ret;
}

7 . 案例-百度网盘密码数据兼容处理

7.1 . 需求和分析

需求：对百度网盘分享链接输入密码时尾部多输入的空格做兼容处理

分析：
①：在业务方法执行之前对所有的输入参数进行格式处理——trim()
②：使用处理后的参数调用原始方法——环绕通知中存在对原始方法的调用

7.2 . 代码实现

7.2.1 . 环境准备
//-------------service层代码-----------------------
public interface ResourcesService {
    public boolean openURL(String url ,String password);
}

@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;

    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}

//-------------dao层代码-----------------------
public interface ResourcesDao {
    boolean readResources(String url, String password);
}

@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}
7.2.2 . 编写通知类
@Component
@Aspect
public class DataAdvice {
    
    @Pointcut("execution(boolean com.service.*Service.*(*,*))")
    private void servicePt(){}

    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }
}
7.2.3 . 在SpringConfig配置类上开启AOP注解功能
@Configuration
@ComponentScan("com")
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class SpringConfig {
}
7.2.4 . 运行测试类，查看结果
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

通过 AOP 中 getArgs() 来得到数据 调用 trim() 方法来解决空格等字符 , 再 通过proceed() 将处理后的值传回去 , 打印 flag

十二 . Spring事务

1 Spring事务简介【重点】

1.1 Spring事务作用

  • 事务作用：在数据层保障一系列的数据库操作同成功同失败
  • Spring事务作用：在数据层或 业务层 保障一系列的数据库操作 同成功同失败

1.2 需求和分析

  • 需求：实现任意两个账户间转账操作
  • 需求微缩：A账户减钱，B账户加钱
  • 分析：
    ①：数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）
    ②：业务层提供转账操作（transfer），调用减钱与加钱的操作
    ③：提供2个账号和操作金额执行转账操作
    ④：基于Spring整合MyBatis环境搭建上述操作
  • 结果分析：
    ①：程序正常执行时，账户金额A减B加，没有问题
    ②：程序出现异常后，转账失败，但是异常之前操作成功，异常之后操作失败，整体业务失败

1.3 代码实现

1.3.1 . 环境准备
Spring整合Mybatis相关代码(依赖、JdbcConfig、MybatisConfig、SpringConfig)省略。
public interface AccountDao {

    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money);

    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money);
}

public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    public void transfer(String out,String in ,Double money) ;
}

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }
}
1.3.2 . 在业务层接口上添加Spring事务管理
public interface AccountService {
    //配置当前接口方法具有事务
    @Transactional
    public void transfer(String out,String in ,Double money) ;
}

注意事项

  1. Spring注解式事务通常添加在业务层接口中而不会添加到业务层实现类中，降低耦合
  2. 注解式事务可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务
1.3.3 . 设置事务管理器(将事务管理器添加到IOC容器中)
说明：可以在JdbcConfig中配置事务管理器
//配置事务管理器，mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSourceTransactionManager dtm = new DataSourceTransactionManager();
    transactionManager.setDataSource(dataSource);
    return transactionManager;
}

注意事项

  1. 事务管理器要根据实现技术进行选择
  2. MyBatis框架使用的是JDBC事务
1.3.4 . 开启注解式事务驱动
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
1.3.5 . 运行测试类，查看结果
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",100D);
    }
}

2 Spring事务角色

2.1 Spring事务角色

  • 事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
  • 事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法

事务角色扮演

3 Spring事务相关配置

3.1 事务配置

事务属性

说明：对于RuntimeException类型异常或者Error错误，Spring事务能够进行回滚操作。但是对于编译器异常，Spring事务是不进行回滚的，所以需要使用rollbackFor来设置要回滚的异常。

3.2 案例：转账业务追加日志

需求和分析
  • 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕
  • 需求微缩：A账户减钱，B账户加钱，数据库记录日志
  • 分析：
    ①：基于转账操作案例添加日志模块，实现数据库中记录日志
    ②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能

  • 实现效果预期：

    无论转账操作是否成功，均进行转账操作的日志留痕

  • 存在的问题：

    日志的记录与转账操作隶属同一个事务，同成功同失败

  • 实现效果预期改进：

    无论转账操作是否成功，日志必须保留
  • 事务传播行为：事务协调员对事务管理员所携带事务的处理态度

业务事务逻辑

3.2.1 . 环境整备
USE spring_db;
CREATE TABLE tbl_log(
    id INT PRIMARY KEY AUTO_INCREMENT,
    info VARCHAR(255),
    createDate DATE
);
public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional
    void log(String out, String in, Double money);
}

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}
3.2.2 . 在AccountServiceImpl中调用logService中添加日志的方法
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private LogService logService;

    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            int i = 1/0;
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
}
3.2.3 . 在LogService的log()方法上设置事务的传播行为
public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}
3.2.4 . 运行测试类，查看结果
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",50D);
    }
}
最后修改：2022 年 12 月 03 日
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏