java后端系统学习总结 05

定义UserDaoFactoryBean实现FactoryBean

UserDaoFactoryBean中实例化什么类型的对象泛型就是该类型。

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class getObjectType() {
        return UserDao.class;
    }
}

applicationContext.xml配置

使用之前的AppForInstanceUser测试类去运行看结果就行了。注意配置文件中id="userDao"是否重复。

package com.itheima;

import com.itheima.dao.OrderDao;
import com.itheima.dao.UserDao;
import com.itheima.factory.OrderDaoFactory;
import com.itheima.factory.UserDaoFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForInstanceOrder {
    //使用工厂创建对象
    public static void main(String[] args) {
        //方法二  静态工厂
                //造对象不要直接new 用工厂的方式做适当的解耦

        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        OrderDao orderDao =(OrderDao) ctx.getBean("orderDao");
        orderDao.save();




        //Spring 的形式来运行

    }
}

问题1：多例的Bean能够配置并执行销毁的方法？

问题2：如何做才执行Bean销毁的方法？

生命周期：从创建到消亡的完整过程bean生命周期：bean从创建到销毁的整体过程bean生命周期控制：在bean创建后到销毁前做一些事情 2 代码演示 2.1 Bean生命周期控制

提供生命周期控制方法

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destroy(){
        System.out.println("destroy...");
    }
}

applicationContext.xml配置

测试类

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nb6tD6op-1647160767870)(Spring%E5%AD%A6%E4%B9%A0.assets/image-20220228210324999.png)]

实现InitializingBean, DisposableBean接口

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        System.out.println("set .....");
        this.bookDao = bookDao;
    }
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //等同于init-method
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }

    //等同于destroy-method
    public void destroy() throws Exception {
        System.out.println("service destroy");
    }
}

测试类代码同《3.2.1 Bean生命周期控制》中的测试代码

容器关闭前触发bean的销毁关闭容器方式：

手工关闭容器
ConfigurableApplicationContext接口close()操作注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机
ConfigurableApplicationContext接口registerShutdownHook()操作

public class AppForLifeCycle {
    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();
    }
}

依赖注入有几种方式？

setter注入

简单类型

引用类型(很常用)

setter方式注入使用什么子标签？

标签中：使用ref

完整代码：

public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    //setter注入需要提供要注入对象的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

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

测试

public class AppForDISet {
    public static void main( String[] args ) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

简单类型包含：基本类型（int, char, long…）+ 特殊类型String

标签中：使用value

完整代码

public class BookDaoImpl implements BookDao {

    private int connectionNum;
    //setter注入需要提供要注入对象的set方法
    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }

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

#简单类型使用value，引用类型使用ref

构造方式注入使用什么子标签？

完整代码

public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }

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

测试

public class AppForDIConstructor {
    public static void main( String[] args ) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

完整代码

public class BookDaoImpl implements BookDao {

    private int connectionNum;
    private String databaseName;

    public BookDaoImpl(String databaseName, int connectionNum) {
        this.databaseName = databaseName;
        this.connectionNum = connectionNum;
    }

    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现可选依赖使用setter注入进行，灵活性强Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入自己开发的模块推荐使用setter注入

BookDaoImpl

package com.itheima.dao.impl;
import com.itheima.dao.BookDao;
public class BookDaoImpl implements BookDao {
    private int connectionNum;
    private String databaseName;


    //注入一：set注入


    //注入二：构造器注入
    public BookDaoImpl(int connectionNum, String databaseName) {
        this.connectionNum = connectionNum;
        this.databaseName = databaseName;
    }

    public void save() {
        System.out.println("book dao..."+ databaseName+","+connectionNum);
    }
}

BookServiceImpl

package com.itheima.service.impl;
import com.itheima.dao.BookDao;
import com.itheima.dao.UserDao;
import com.itheima.service.BookService;

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    private UserDao userDao;
    
    //注入方法一：set注入

    //注入方法二：构造器注入
    public BookServiceImpl(BookDao bookDao, UserDao userDao) {
        this.bookDao = bookDao;
        this.userDao = userDao;
    }

    public void save() {
        System.out.println("book service...");
        bookDao.save();
        userDao.save();
    }
}

AppForDISet

package com.itheima;
import com.itheima.service.BookService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForDISet {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx= new ClassPathXmlApplicationContext("applicationContext.xml");

        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();

        ctx.close();
    }
}

applicationContext.xml




        
    

    

    

    
    
        
        
    
    
    
        
        
    

如何配置按照类型自动装配？

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

自动装配方式

按类型（常用）

按名称：

按构造方法

不启用自动装配

配置中使用bean标签autowire属性设置自动装配的类型

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

在类中添加集合类型属性：添加get，set方法

public class BookDaoImpl implements BookDao {

    private int[] array;

    private List list;

    private Set set;

    private Map map;

    private Properties properties;

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

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

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

    public void setMap(Map map) {
        this.map = map;
    }

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

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

        System.out.println("遍历数组:" + Arrays.toString(array));

        System.out.println("遍历List" + list);

        System.out.println("遍历Set" + set);

        System.out.println("遍历Map" + map);

        System.out.println("遍历Properties" + properties);
    }
}

    
        100
        200
        300
    

    
        itcast
        itheima
        boxuegu
        chuanzhihui
    

    
        itcast
        itheima
        boxuegu
        boxuegu
    

    
        china
        henan
        kaifeng
    

说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写、、、

public class AppForDICollection {
    public static void main( String[] args ) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");

        bookDao.save();
    }
}

说明：以管理DataSource连接池对象为例讲解第三方资源配置管理

配置数据库连接参数时，注入驱动类名是用driverClassName还是driver？

数据库准备

create database if not exists spring_db character set utf8;
use spring_db;
create table if not exists tbl_account(
    id int primary key auto_increment,
    name varchar(20),
    money double
);
insert into tbl_account values(null,'Tom',1000);
insert into tbl_account values(null,'Jerry',1000);

【第一步】添加Druid连接池依赖

    org.springframework
    spring-context
    5.2.10.RELEASE


    com.alibaba
    druid
    1.1.16


    mysql
    mysql-connector-java
    5.1.47

注意：除了添加以上两个依赖之外，别忘了添加spring-context依赖。

【第二步】配置DruidDataSource连接池Bean对象

【第三步】在测试类中从IOC容器中获取连接池对象并打印

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

【第一步】添加c3p0连接池依赖

    c3p0
    c3p0
    0.9.1.2

【第二步】配置c3p0连接池Bean对象

注意：同一个Spring容器中不能有两个id="dataSource"的连接池。

【第三步】在测试类中从IOC容器中获取连接池对象并打印

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

目的：将数据库的连接参数抽取到一个单独的文件中，与Spring配置文件解耦。

问题1：如何解决使用EL表达式读取属性文件中的值结果读取到了系统属性问题？

问题2：加载properties文件写法标准写法该怎么写？

【第一步】编写jdbc.properties属性文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root

【第二步】在applicationContext.xml中开启开启context命名空间，加载jdbc.properties属性文件

小技巧：如果同学们觉得上述复制粘贴方式不好改或者容易改错，其实idea是有提示功能的，注意不要选错就行了。

【第三步】在配置连接池Bean的地方使用EL表达式获取jdbc.properties属性文件中的值

配置完成之后，运行之前的获取Druid连接池代码，可以获取到连接池对象就表示配置成功。

问题

如果属性文件中配置的不是jdbc.username，而是username=root666，那么使用${username}获取到的不是root666，而是计算机的名称。

原因

系统属性的优先级比我们属性文件中的高，替换了我们的username=root666。

解决

解决1：换一个名称，例如不叫username，叫jdbc.username。

解决2：使用system-properties-mode="NEVER"属性表示不使用系统属性。

不加载系统属性

加载多个properties文件

加载所有properties文件

加载properties文件**标准格式**

加载当前工程类路径和当前工程所依赖的所有jar包中的所有properties文件

问题：按照Bean名称获取Bean有什么弊端，按照Bean类型获取Bean有什么弊端？

方式一：类路径加载配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

方式二：文件路径加载配置文件

ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\applicationContext.xml");

加载多个配置文件

ApplicationContext ctx = new ClassPathXmlApplicationContext("bean1.xml", "bean2.xml");

方式一：使用bean名称获取

弊端：需要自己强制类型转换

BookDao bookDao = (BookDao) ctx.getBean("bookDao");

方式二：使用bean名称获取并指定类型（推荐使用）

BookDao bookDao = ctx.getBean("bookDao", BookDao.class);

方式三：使用bean类型获取

弊端：如果IOC容器中同类型的Bean对象有多个，此处获取会报错

BookDao bookDao = ctx.getBean(BookDao.class);

类路径加载配置文件

Resource resources = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(resources);
BookDao bookDao = bf.getBean("bookDao", BookDao.class);
bookDao.save();

BeanFactory创建完毕后，所有的Bean均为延迟加载，也就是说我们调用getBean()方法获取Bean对象时才创建Bean对象并返回给我们 2 Spring核心容器总结 2.1 容器相关

BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载

ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载

ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能

ApplicationContext接口常用初始化类

ClassPathXmlApplicationContext(常用)FileSystemXmlApplicationContext

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r3wrgJMC-1647160767873)(Spring%E5%AD%A6%E4%B9%A0.assets/image-20210730103438742.png)]

目的：xml配置Bean对象有些繁琐，影响开发速度，因此咱们使用注解简化Bean对象的定义

问题1：使用什么标签进行Spring注解包扫描？

问题2：@Component注解和@Controller、@Service、@Repository三个衍生注解有什么区别？

【第一步】在applicationContext.xml中开启Spring注解包扫描

【第二步】在类上使用@Component注解定义Bean。

//@Component定义bean
@Component("bookDao")
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}

@Component
public class BookServiceImpl implements BookService {

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

补充说明：如果@Component注解没有使用参数指定Bean的名称，那么类名首字母小写就是Bean在IOC容器中的默认名称。例如：BookServiceImpl对象在IOC容器中的名称是bookServiceImpl。

【第三步】在测试类中获取Bean对象

public class AppForAnnotation {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        //按类型获取bean
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

运行结果

说明：加粗的注解为常用注解

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

@Controller：用于表现层bean定义@Service：用于业务层bean定义@Repository：用于数据层bean定义

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
}

@Service
public class BookServiceImpl implements BookService {
}

问题1：配置类上使用什么注解表示该类是一个配置类？

问题2：配置类上使用什么注解进行Spring注解包扫描？

Spring3.0开启了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道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);

【第一步】定义配置类代替配置文件

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

【第二步】在测试类中加载配置类，获取Bean对象并使用

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

注解开发转换：从核心配置文件初始化容器对象切换为读取java配置类初始化容器对象

在类上使用什么注解定义Bean的作用范围？

使用@Scope定义bean作用范围

@Repository
@Scope("singleton")//单例
@Scope("prototype")//非单例
public class BookDaoImpl implements BookDao {
}

使用@PostConstruct、@PreDestroy定义bean生命周期

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor ...");
    }
    @PostConstruct
    public void init(){
        System.out.println("book init ...");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("book destory ...");
    }
}

#注意：@PostConstruct和@PreDestroy注解是jdk中提供的注解，从jdk9开始，jdk中的javax.annotation包被移除了，也就是说这两个注解就用不了了，可以额外导入一下依赖解决这个问题。

  javax.annotation
  javax.annotation-api
  1.3.2

问题1：请描述@Autowired注解是如何进行自动装配的？

问题2：请描述@Qualifier注解的作用

@Service
public class BookServiceImpl implements BookService {
    
    @Autowired //注入引用类型，自动装配模式，默认按类型装配
    private BookDao bookDao;

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

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

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

@Service
public class BookServiceImpl implements BookService {
    @Autowired  //注入引用类型，自动装配模式，默认按类型装配。不加这个装配，bookDao 是空对象

    @Qualifier("bookDao2")  //自动装配bean时按bean名称装配  装配哪个dao
    private BookDao bookDao;

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

注意：@Qualifier注解无法单独使用，必须配合@Autowired注解使用

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    //@Value：注入简单类型（无需提供set方法）
    @Value("${name}")
    private String name;

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

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

@PropertySource加载properties配置文件

@Configuration
@ComponentScan("com.itheima")
//@PropertySource加载properties配置文件
@PropertySource({"classpath:jdbc.properties"}) //单个配置文件{}可以省略不写
//@PropertySource("classpath:jdbc.properties") 
public class SpringConfig {
}

==注意：@PropertySource()中加载多文件请使用数组格式配置，不允许使用通配符==*

导入自己定义的配置类有几种方式？

public class JdbcConfig {
    //@Bean：表示当前方法的返回值是一个bean对象，添加到IOC容器中
    @Bean("dataSource") //不写名称，则使用方法名作为对象id： 
【第二步】将独立的配置类加入核心配置 
方式1：@import注解导入式 
@Configuration
@ComponentScan("com.itheima")
//@import:导入配置信息
@import({JdbcConfig.class})
public class SpringConfig {
}
 
方式2：JdbcConfig上使用@Configuration 
@Configuration
public class JdbcConfig {
    //省略...
}
 
测试：
 
public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        DataSource dataSource = ctx.getBean(DataSource.class);
        System.out.println(dataSource);
    }
}
 
 
 
6 注解开发为第三方Bean注入资源【重点】 
问题导入 
配置类中如何注入简单类型数据，如何注入引用类型数据？
 
6.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属性文件。
 
 
6.2 引用类型依赖注入 
//Spring会自动从IOC容器中找到BookDao对象赋值给参数bookDao变量，如果没有就会报错。
@Bean 
public DataSource dataSource(BookDao bookDao){
    System.out.println(bookDao);
    DruidDataSource ds = new DruidDataSource();
    ds.setDriverClassName(driver);
    ds.setUrl(url);
    ds.setUsername(userName);
    ds.setPassword(password);
    return ds;
}
 
 
 
说明：引用类型注入只需要为bean定义方法设置形参即可，容器会根据类型自动装配对象
 
 
7 注解开发总结 
常用：@Service @ComponentScan @Autowired @bean
 
 
四、Spring整合其他技术【重点】 
1 Spring整合mybatis【重点】 
1.1 思路分析 
问题导入 
mybatis进行数据层操作的核心对象是谁？
 
1.1.1 MyBatis程序核心对象分析 
SqlSessionFactory 最核心的对象，在这一步 对象已经造好了
 
 
 
1.1.2 整合MyBatis 
mybatis管理的是sqlsessionfactory对象
 
使用SqlSessionFactoryBean封装SqlSessionFactory需要的环境信息 
 
使用MapperScannerConfigurer加载Dao接口，创建代理对象保存到IOC容器中 
 
1.2 代码实现 
问题导入 
问题1：Spring整合mybatis的依赖叫什么？
 
问题2：Spring整合mybatis需要管理配置哪两个Bean，这两个Bean作用分别是什么？
 
【前置工作】 
  

    
      org.mybatis
      mybatis
      3.5.6
    
    
      mysql
      mysql-connector-java
      5.1.47
    

    
      org.springframework
      spring-context
      5.2.10.RELEASE
    
    
      com.alibaba
      druid
      1.1.16
    

    
    
      org.springframework
      spring-jdbc
      5.2.10.RELEASE
    
    
    
      org.mybatis
      mybatis-spring
      1.3.0
    
  
 
 
在pom.xml中添加spring-context、druid、mybatis、mysql-connector-java等基础依赖。
 

  org.springframework
  spring-context
  5.2.10.RELEASE


  com.alibaba
  druid
  1.1.16



  org.mybatis
  mybatis
  3.5.6



  mysql
  mysql-connector-java
  5.1.47

  
准备service和dao层基础代码
 
public interface AccountService {

    void save(Account account);

    void delete(Integer id);

    void update(Account account);

    List findAll();

    Account findById(Integer id);

}

public interface AccountDao {

    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);

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

    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);

    @Select("select * from tbl_account")
    List findAll();

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

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void save(Account account) {
        accountDao.save(account);
    }

    public void update(Account account){
        accountDao.update(account);
    }

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

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    public List findAll() {
        return accountDao.findAll();
    }
}
 
 
【第一步】导入Spring整合Mybatis依赖 
    

    org.springframework
    spring-jdbc
    5.2.10.RELEASE


    

    org.mybatis
    mybatis-spring
    1.3.0

 
【第二步】创建JdbcConfig配置DataSource数据源 
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root
 
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 ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}
 
【第三步】创建MybatisConfig整合mybatis 
public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象        //初始化dataSource
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);//注入引用类型的对象   形参上传入
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象         //初始化映射配置  mapper
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setbasePackage("com.itheima.dao");
        return msc;
    }
}
 
【第四步】创建SpringConfig主配置类进行包扫描和加载其他配置类 
@Configuration
@ComponentScan("com.itheima")
//@PropertySource：加载类路径jdbc.properties文件
@PropertySource("classpath:jdbc.properties")
@import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
 
【第五步】定义测试类进行测试 
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

        AccountService accountService = ctx.getBean(AccountService.class);

        Account ac = accountService.findById(1);
        System.out.println(ac);
    }
}
 
两个bean需要配置
 
 
 
2 Spring整合Junit单元测试【重点】 
问题导入 
Spring整合Junit的两个注解作用分别是什么？
 
【第一步】导入整合的依赖坐标spring-test 

  junit
  junit
  4.12



  org.springframework
  spring-test
  >5.2.10.RELEASE

 
【第二步】使用Spring整合Junit专用的类加载器 
【第三步】加载配置文件或者配置类 
//【第二步】使用Spring整合Junit专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
//【第三步】加载配置文件或者配置类
@ContextConfiguration(classes = {SpringConfiguration.class}) //加载配置类
//@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加载配置文件
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;

    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));
    }

    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }
}
 
注意：junit的依赖至少要是4.12版本,可以是4.13等版本,否则出现如下异常：
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nX8SlOgB-1647160767877)(Spring%E5%AD%A6%E4%B9%A0.assets/image-20200831155517797.png)]
 
//第一步设定类运行器.  spring整合junit的专用类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//告知spring环境
@ContextConfiguration(classes = SpringConfig.class)  //spring整合junit的环境已经搭建好了
public class AccountServiceTest {
//    测试业务层接口

    //保证能用,自动装配
    @Autowired
    private AccountService accountService;
    //测试方法
    @Test
    public void  testFindById() {
        System.out.println(accountService.findById(1));
    }

    @Test
    public void testFindAll() {
        System.out.println(accountService.findAll());
    }
}
 
 
three 
一、AOP 
 
1 AOP简介 
问题导入 
做无侵入式功能增强
 
问题1：AOP的作用是什么？
 
问题2：连接点和切入点有什么区别，二者谁的范围大？
 
问题3：请描述什么是切面？
 
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）：描述通知与切入点的对应关系，也就是哪些通知方法对应哪些切入点方法。   
 
2 AOP入门案例【重点】-11’45 
问题导入 
问题1：在通知方法中如何定义切入点表达式？
 
问题2：如何配置切面？
 
问题3：在配置类上如何开启AOP注解功能？
 
2.1 AOP入门案例思路分析 
案例设定：测定接口执行效率简化设定：在接口执行前输出当前系统时间开发模式：XML or 注解思路分析： 
  
导入坐标（pom.xml） ** **制作连接点方法（原始操作，dao接口与实现类）制作共性功能（通知类与通知）定义切入点绑定切入点与通知关系（切面）
  
2.2 AOP入门案例实现 
【第一步】导入aop相关坐标 

    
    
        org.springframework
        spring-context
        5.2.10.RELEASE
    
    
    
        org.aspectj
        aspectjweaver
        1.9.4
    

 
 
【第二步】定义dao接口与实现类 
public interface BookDao {
    public void save();
    public void update();
}

@Repository
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }
    public void update(){
        System.out.println("book dao update ...");
    }
}
 
【第三步】定义通知类，制作通知方法 
 
//通知类必须配置成Spring管理的bean
@Component
public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
 
【第四步】定义切入点表达式、配置切面(绑定切入点与通知关系) 
@Component
@Aspect
public class Aop {
    @Pointcut("execution(* com..AccountService.save())")
    private void pt(){}

    @Around("pt()")
    public Object method(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("before");
        Object proceed = pjp.proceed();
        System.out.println("after");
        return proceed;
    }
}
 
//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，@Pointcut注解要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

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

@Component  //1.扫描到这个文件，加载到spring中
@Aspect     //2.当作AoP来操作
public class MyAdvice {
    //3.第四步  先写一个私有方法，定义为切入点
            //execution执行  括号内描述连接点
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //5.切入点与共性方法的关系，共性方法在切入点之前执行   绑定切入点与通知
    @Before("pt()")
    //4.定义通知
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
 
 
【第五步】在配置类中进行Spring注解包扫描和开启AOP功能 
@Configuration
@ComponentScan("com.itheima")
//开启注解开发AOP功能
@EnableAspectJAutoProxy
public class SpringConfig {
}
 
@Configuration
@ComponentScan("com.itheima")

@EnableAspectJAutoProxy   //告诉spring 我这里面有用注解开发的aop    启动了通知类里面的Aspect，而通知类中的aspect告诉了spring进入后要识别通知
public class SpringConfig {
}
 
测试类和运行结果 
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}
 
 
3 AOP工作流程【理解】-07’24 
AOP内部是用代理模式进行工作的
 
问题导入 
什么是目标对象？什么是代理对象？
 
3.1 AOP工作流程 
匹配失败，还没有进入aop模式
 
Spring容器启动读取所有切面配置中的切入点初始化bean，判定bean对应的类中的方法是否匹配到任意切入点 
  
匹配失败，创建原始对象匹配成功，创建原始对象（目标对象）的代理对象 获取bean执行方法 
  
获取的bean是原始对象时，调用方法并执行，完成操作获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作 
 
3.2 AOP核心概念 
目标对象（Target）：被代理的对象，也叫原始对象，该对象中的方法没有任何功能增强。
 代理对象（Proxy）：代理后生成的对象，由Spring帮我们创建代理对象。
 
3.3 在测试类中验证代理对象 
@Component  //1.扫描到这个文件，加载到spring中
@Aspect     //2.当作AoP来操作
public class MyAdvice {
    //3.第四步  先写一个私有方法，定义为切入点
            //execution执行  括号内描述连接点
            //        更改为update1  就比配不到了，就不会走代理模式的路径 bean.getClass()打印出的是 com.itheima.dao.impl.BookDaoImpl
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //5.切入点与共性方法的关系，共性方法在切入点之前执行   绑定切入点与通知
    @Before("pt()")
    //4.定义通知
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
 
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
		//打印对象的类名
        System.out.println(bookDao.getClass());
    }
}
 
 
 
4 AOP切入点表达式-19’29 
问题导入 
在切入点表达式中如何简化包名和参数类型书写？
 
4.1 语法格式 
 
切入点：要进行增强的方法
  
切入点表达式：要进行增强的方法的描述方式
 
  
描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法 
execution(void com.itheima.dao.BookDao.update())
 
  
描述方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法 
execution(void com.itheima.dao.impl.BookDaoImpl.update())
  
切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）
 
execution(public User com.itheima.service.UserService.findById(int))
 
  
  动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点访问修饰符：public，private等，可以省略返回值：写返回值类型包名：多级包使用点连接类/接口名：方法名：参数：直接写参数的类型，多个类型用逗号隔开异常名：方法定义中抛出指定异常，可以省略  
4.2 通配符 
 
 
目的：可以使用通配符描述切入点，快速描述。
 
 
：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现 
 
 
匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法
 
 
execution（public * com.itheima.*.UserService.find*(*))
 
没有参数的 加*，加载不出来 加 … 都可以加载出来
 
… ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写 
 
 
匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法
 
 
execution（public User com..UserService.findById(..))
 
+：专用于匹配子类类型 
execution(* *..*Service+.*(..))
/
    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);
    }
}
 
【第一步】在业务层接口上添加Spring事务管理 
public interface AccountService {
    //配置当前接口方法具有事务
    @Transactional
    public void transfer(String out,String in ,Double money) ;
}
 
注意事项
 
Spring注解式事务通常添加在业务层接口中而不会添加到业务层实现类中，降低耦合@Transactional可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务
 
【第二步】设置事务管理器(将事务管理器添加到IOC容器中) 
 
 
说明：可以在JdbcConfig中配置事务管理器
 
 
//配置事务管理器，mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSourceTransactionManager dtm = new DataSourceTransactionManager();
    transactionManager.setDataSource(dataSource);
    return transactionManager;
}
 
注意事项
 
事务管理器要根据实现技术进行选择MyBatis框架使用的是JDBC事务
 
【第三步】开启注解式事务驱动 
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
 
【第四步】运行测试类，查看结果 
@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中通常指代数据层方法，也可以是业务层方法三个事务变为一个事务 用来管理。所有操作同成功同失败 
 
他们用了同一个datasource 事务源相同，所以合并成了同一个事务
 
 
3 Spring事务相关配置-18’43 
问题导入 
什么样的异常，Spring事务默认是不进行回滚的？
 
3.1 事务配置 
运行时异常，溢出error异常能回滚，除此之外不支持回滚
 
 
 
 
说明：对于RuntimeException类型异常或者Error错误，Spring事务能够进行回滚操作。但是对于编译器异常，Spring事务是不进行回滚的，所以需要使用rollbackFor来设置要回滚的异常。
 
 
3.2 案例：转账业务追加日志 
需求和分析 
需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕需求微缩：A账户减钱，B账户加钱，数据库记录日志分析：
 ①：基于转账操作案例添加日志模块，实现数据库中记录日志
 ②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能实现效果预期：
 无论转账操作是否成功，均进行转账操作的日志留痕存在的问题：
 日志的记录与转账操作隶属同一个事务，同成功同失败实现效果预期改进：
 无论转账操作是否成功，日志必须保留事务传播行为：事务协调员对事务管理员所携带事务的处理态度 
 
【准备工作】环境整备 
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);
}
 
【第一步】在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);
        }
    }
}
 
【第二步】在LogService的log()方法上设置事务的传播行为 分离绑定事务 
public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}
 
【第三步】运行测试类，查看结果 
@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);
    }
}
 
3.3 事务传播行为 
 
eTransactionManager dtm = new DataSourceTransactionManager();
 transactionManager.setDataSource(dataSource);
 return transactionManager;
 }
 
注意事项

1. 事务管理器要根据实现技术进行选择
2. MyBatis框架使用的是JDBC事务

##### 【第三步】开启注解式事务驱动

```java
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
 
【第四步】运行测试类，查看结果 
@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中通常指代数据层方法，也可以是业务层方法三个事务变为一个事务 用来管理。所有操作同成功同失败 
[外链图片转存中…(img-DRU2w4HL-1647160767880)]
 
他们用了同一个datasource 事务源相同，所以合并成了同一个事务
 
[外链图片转存中…(img-KspsMrTX-1647160767880)]
 
3 Spring事务相关配置-18’43 
问题导入 
什么样的异常，Spring事务默认是不进行回滚的？
 
3.1 事务配置 
运行时异常，溢出error异常能回滚，除此之外不支持回滚
 
[外链图片转存中…(img-Sf2Z16En-1647160767881)]
 
 
 
说明：对于RuntimeException类型异常或者Error错误，Spring事务能够进行回滚操作。但是对于编译器异常，Spring事务是不进行回滚的，所以需要使用rollbackFor来设置要回滚的异常。
 
 
3.2 案例：转账业务追加日志 
需求和分析 
需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕需求微缩：A账户减钱，B账户加钱，数据库记录日志分析：
 ①：基于转账操作案例添加日志模块，实现数据库中记录日志
 ②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能实现效果预期：
 无论转账操作是否成功，均进行转账操作的日志留痕存在的问题：
 日志的记录与转账操作隶属同一个事务，同成功同失败实现效果预期改进：
 无论转账操作是否成功，日志必须保留事务传播行为：事务协调员对事务管理员所携带事务的处理态度 
[外链图片转存中…(img-t3416Ir2-1647160767881)]
 
【准备工作】环境整备 
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);
}
 
【第一步】在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);
        }
    }
}
 
【第二步】在LogService的log()方法上设置事务的传播行为 分离绑定事务 
public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}
 
【第三步】运行测试类，查看结果 
@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);
    }
}
 
3.3 事务传播行为 
[外链图片转存中…(img-RzQxh5hZ-1647160767881)]
 

 以上内容来自黑马学习笔记，笔记上传便于复习回顾。