ShanTianQi

Spring

第一章 Spring


1.1基础


Spring全家桶

20220617194846

发展史

20220617195507


1.2Spring系统架构


Spring Framework是Spring生态圈中最基础的项目,是其他项目的根基

20220617200429

学习路线:

20220620090533


1.3核心概念


一、IoC/DI

之前实现:

20220620092220

现在实现:

20220620092321

目标:充分解耦

效果:

二、IoC容器

入门案例

20220620094128

1.导入Spring坐标

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

2.定义Spring管理的类(接口)

public interface BookService {
	public void save();
}
public class BookServiceImpl implements BookService {
	private BookDao bookDao = new BookDaoImpl();
	
	public void save(){
		bookDao.save();
	}
}

3.创建Spring配置文件,配置对应类作为Spring管理的bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http: / /www.springframework.org/schema/beans"
	xmlns:xsi="http: / /www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
					  https://www.springframework.org/schema/beans/spring-beans.xsd">
   <!--    1.导入spring的坐标spring-context-->

<!--    2.配置bean-->
<!--    bean标签表示配置bean,id属性表示给bean起名字,class属性表示给bean定义类型-->
    <bean id="bookDao" class="com.priv.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.priv.service.impl.BookServiceImpl"/>
</beans>

tips:bean定义时id属性在同一个上下文中不能重复

package com.priv;

import com.priv.dao.BookDao;
import com.priv.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author : 十一
 * @data : 19:06 2022/11/5
 */
public class App2 {
    public static void main(String[] args) {
        //3.获取IOC容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //4.获取bean
//        BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
//        bookDao.save();
        BookService bookService = (BookService) applicationContext.getBean("bookService");
        bookService.save();
    }
}

三、DI

入门案例

20220620200853

1.删除使用new的形式创建对象的代码

public class BookServiceImpl implements BookService {
	private BookDao bookDao;//private BookDao bookDao = new BookDaoImpl();
    
    public void save() {
        bookDao.save();
    }
}

2.提供依赖对象对应的setter方法

public class BookServiceImpl implements BookService {
	private BookDao bookDao;
    
    public void save() {
        bookDao.save();
    }
    
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

3.配置service与dao之间的关系

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
					  https://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="bookService" class="com.itheima.di.service.impl.BookServiceImpl">
	  <property name="bookDao" ref="bookDao"/><!-- name里的bookDao就是上面第二行的bookDao这个属性(对象),ref里的bookDao就是下面第九行的bookDao这个bean-->
  </bean>
  <bean id="bookDao" class="com.itheima.di.dao.impl.BookDaoImpl" />
</beans>

四、Bean

1.bean基础配置:

<beans>
	<bean/>
	<bean></bean>
</beans>
<bean id="bookDao" class="com.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.service.impl.BookServiceImpl"></bean>

2.bean别名配置

<bean id="bookDao" naem="dao bookDaoImpl" class="com.dao.impl.BookDaoImpl"/>
<bean name="service,bookServiceImpl" class="com.service.impl.BookServiceImpl"/>

tips:获取bean无论是通过id还是name获取,如果无法获取到,将抛出异常NoSuchBeanDefinitionException:NoSuchBeanDefinitionException: No bean named ‘bookServiceImpl’ available

3.bean作用范围配置

<bean id="bookDao" class="com.dao.impl.BookDaoImpl" scope="prototype"/>

适合交给容器进行管理的bean

不适合交给容器进行管理的bean

4.bean的实例化

一、构造方法

public class BookDaoImpl implements BookDao {
	public BookDaoImpl(){
		System.out.println( "book constructor is running ...");
    }
	public void save() {
		system.out.println( "book dao save ..." );
    }
}
<bean id="bookDao" class="com.dao.impl.BookDaoImpl"/>

二、静态工厂

public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        return new OrderDaoImpl();
    }
}
<bean id="orderDao" factory-method="getOrderDao" class="com.factory.OrderDaoFactory"/>
<!--如果不加factory-method="getOrderDao"造出来的是Factory对象,要配置工厂里真正造对象的那个方法名-->

三、实例工厂

public class UserDaoFactory {
	public UserDao getUserDao(){
		return new UserDaoImpl();
	}
}
<bean id="userFactory" class="com.factory.UserDaoFactory" /><!--先造工厂对象-->
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory" />

配置太麻烦,优化一下:

代替原始实例工厂中创建对象的方法

创建的对象是单例的,如果想改成非单例的:实现isSingleton方法,return false即可实现

package com.factory;

import com.dao.UserDao;
import com.dao.imp1.userDaoImpl;
import org.springframework.beans.factory.FactoryBean;

public class UserDaoFactoryBean implements FactoryBean<UserDao> {
	//代替原始实例工厂中创建对象的方法
	public UserDao getobject() throws Exception {
		return new UserDaoImpl();
	}
	public class<?> getobjectType() {
     	return UserDao.class;
    }
}
<bean id="userDao" class="com.factory.UserDaoFactoryBean" />

1.4bean的生命周期


控制生命周期:

第一种 配置实现

//获取bean实例对象
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//容器关闭前触发bean的销毁
//调用销毁(destroy)方法
//方法一:手动关闭容器(在最后)
ctx.close();//比较暴力
//方法二:注册关闭钩子,在虚拟机退出前先关闭容器再退出虚拟机
ctx.registerShutdownHook();
<!--配置
    在BookDaoImpl中定义两个方法init()和destory()-->
<bean id="bookDao" class="com.dao.impl.BookDaoImpl" init-method="init" destroy-method="destroy"/>

第二种 接口实现

implements InitializingBean,DisposableBean

方法重载

这种方法就不用在配置文件中去设置init-method=“init” destroy-method=“destroy”了

生命周期


1.5依赖注入(DI)


方式

一、setter注入引用类型(之前说过)

public class BookServiceImpl implements BookService {
	private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}
<bean id="bookService" class="com.service.impl.BookServiceImpl">
	<property name="bookDao" ref="bookDao"/>
</bean>
<bean id="bookDao" class="com.dao.impl.BookDaoImpl"/>

二、setter注入简单类型

public class BookDaoImpl implements BookDao {
    private String databaseName;
    private int connextionNumber;
    
    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }
    
    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }
}
<bean id="bookDao" class="com.dao.impl.BookDaoImpl">
    <property name="databaseName" value="mysql"/>
    <property name="connectionNum" value="100">
</bean>

三、构造器注入引用类型(了解)

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public BookServiceImpl(BookDao bookDao) {
        thos.bookDao = bookDao;
    }
}
<bean id="bookService" class="com.service.impl.BookServiceImpl">
	<constructor-arg name="bookDao" ref="bookDao" /><!--name名就是形参的名称-->
</bean>
<bean id="bookDao" class="com.dao.impl.BookDaoImpl" />

四、构造器注入简单类型

public class BookDaoImpl implements BookDao {
    private int connectionNumber;
    public void setConnectionNumber(int connectionNumber) {
        this.connectionNumber = connectionNumber;
    }
}
<bean id="bookDao" class="com.dao.impl.BookDaoImpl">
	<constructor-arg name="connectionNumber" value="10"/>
</bean>

tips:这种用name属性的方式耦合性太高,name后面接的是构造方法参数名称。这里可以利用type(形参类型)或者index(位置编号)属性替换。


依赖自动装配

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

<bean id="bookDao" class="com.dao.impl.BookDaoImpl" />
<bean id="bookService" class="com.service.impl.BookServiceImpl" autowire="byType"/>
<!--byName是匹配bean的id名称与setter方法名首字母变小写-->

特征


1.6集合注入


<bean id="bookDao" class="com.dao.impl.BookDaoImpl">
    <property name="array">
        <array>
            <value>100</value>
            <value>200</value>
            <value>300</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>js</value>
            <value>java</value>
            <value>python</value>
        </list>
    </property>
    <property name="set">
        <set>
            <value>100</value>
            <value>200</value>
            <value>300</value>
            <value>300</value>#会过滤掉
        </set>
    </property>
    <property name="map">
        <map>
            <entry key="country" value="china"/>
            <entry key="province" value="liaoning"/>
            <entry key="city" value="shenyang"/>
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="country">china</prop>
            <prop key="province">liaoning</prop>
            <prop key="city">shenyang</prop>
        </props>
    </property>
</bean>

1.7数据源对象管理


一、druid

管理DruidDataSource对象

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

二、C3P0

管理ComboPooledDataSource对象

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/students"/>
    <property name="user" value="root"/>
    <property name="password" value="root"/>
    。。。
</bean>

这么写显然是不合适的。。。

看下面


1.8加载properties


一、开启context命名空间第3,7,8行。

将第1行复制到第3行,5,6复制到7,8,改context

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

二、使用context空间加载properties文件

<context:property-placeholder location="jdbc.properties"/>

三、使用属性占位符${}读取prroperties文件中的属性

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/students
jdbc.username=root
jdbc.password=root

#假设设置,并且把占位符中的jdbc.username改为username,调用结果可能不是Echo
#可能会与系统环境变量产生冲突,而且系统环境变量优先级高,所以如果要使用自定义名称的话,可以在
#<context:property-placeholder location="jdbc.properties"/>中添加
#system-properties-mode="NEVER"
username=Echo

tips:加载多个配置文件,直接逗号即可,或者直接使用classpath*:*property,加载所有配置文件

classpath*:*property和classpath:*property的区别


1.9容器


一、创建容器

//1.加载类路径下的配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationcontext.xm1");
//2.从文件系统下加载配置文件(了解即可)
ApplicationContext ctx = new FileSystemXmlApplicationContext("绝对路径")

二、获取bean

//1.使用bean名称获取
BookDao bookDao = (BookDao)ctx.getBean("bookDao");
//2.使用bean名称获取并指定类型
BookDao bookDao = ctx.getBean("bookDao", BookDao.class);
//3.使用bean类型获取
BookDao bookDao = ctx.getBean(BookDao.class);

三、容器类层次结构

20220706134822

四、BeanFactory

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

tips:如果想让ApplicationContext创建后,bean也为延迟加载,可以在配置文件中bean添加lazy-init="true"


1.10阶段总结


一、容器相关

20220706135644

二、bean相关

20220706135533

三、依赖注入相关

20220706135629


1.11注解开发


1.11.1注解开发定义bean

@Component("bookDao")
public class BookDaoImpl implements BookDao {

}
@Component
public class BookServiceImpl implements BookService {

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

1.11.2纯注解开发

Spring3.0升级了纯注解开发模式,使用Java类替代配置文件,开启了Spring快速开发赛道

20220710174402

@ComponentScan({"com.service","com.dao"})

读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象

//加载配置文件初始化容器
ApplicationContext ctx = new classPathXmlApplicationContext("applicationContext.xml" );
//加载配置类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

1.11.3bean的管理

一、bean作用范围

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

二、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 destroy ...");
    }
}

1.11.4依赖注入

20220710180912

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

自动装配建议使用无参构造方法创建对象(默认),如果不提供对应构造方法,请提供唯一的构造方法。

20220710181249

tips:@Qualifier注解无法单独使用,必须配合@Autowired注解使用

20220710181531 20220710182007

tips:路径仅支持单一文件配置,多文件请使用数组格式配置,不允许使用通配符*

1.11.5第三方bean管理

一、第三方bean管理

@Configuration
public class SpringConfig {
    @Bean
    public DataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/students");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}
public class JdbcConfig {
    @Bean
    public DataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/students");
        ds.setUsername("root");
        ds.setPassword("root");
        return ds;
    }
}
public class JdbcConfig {
    @Bean
    public DataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        
        //相关配置
        return ds;
    }
}
@Configuration
@Import(JdbcConfig.class)//写多个用{}
public class SpringConfig {
}
@Configuration
public class JdbcConfig {
    @Bean
    public DataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        
        //相关配置
        return ds;
    }
}
@Configuration
@ComponentScan({"com.config","com.service","com.dao"})
public class SpringConfig {
}

二、第三方bean依赖注入

20220710185710

20220710185754

引用类型注入只需要为bean定义方法设置形参即可,容器会根据类型自动装配对象

1.11.6注解总结

20220710190054


1.12Spring整合MyBatis


导坐标:

mybatis配置文件换成spring整合

两个bean:

20220716174524

20220716174547

实际:把sqlMapConfig.xml换成Spring的MybatisConfig.java

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--通过properties标签加载外部properties文件-->
    <properties resource="jdbc.properties"></properties>

    <typeAliases>
        <typeAlias type="com.priv.domain.Account" alias="account"></typeAlias>
    </typeAliases>

    <!--数据源环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <package name="com.priv.dao"/>
    </mappers>

</configuration>
package com.priv.config;

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

import javax.sql.DataSource;

/**
 * @author : 十一
 * @data : 14:12 2022/12/14
 */
public class MybatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setTypeAliasesPackage("com.priv.domain");
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.priv.dao");
        return mapperScannerConfigurer;
    }
}

20221214142646


1.13Spring整合JUnit


导两个坐标:junit和spring-test

如果不整合会报空指针异常java.lang.NullPointerException(一开始我好奇如果不整合直接使用会出现什么问题,结果试了一下会报空指针)

package com.priv;

import com.priv.config.SpringConfig;
import com.priv.domain.Account;
import com.priv.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * @author : 十一
 * @data : 14:33 2022/12/14
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testSave(){
        List<Account> all = accountService.findAll();
        System.out.println(all);
    }
}

1.14AOP


1.14.1简介


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

作用:在不惊动原始设计的基础上为其进行功能增强。

Spring理念:无入侵式/无侵入式

20220724191910


1.14.2AOP入门案例


一、导入aop坐标

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

​ 20220730210002

二、定义dao接口与实现类

package com.dao;

/**
 * @author : 十一
 * @data : 20:12 2022/7/30
 * When in doubt, use brute force.
 */
public interface BookDao {
    public void save();
    public void update();
}
package com.dao.impl;

import com.dao.BookDao;
import org.springframework.stereotype.Repository;

/**
 * @author : 十一
 * @data : 20:12 2022/7/30
 * When in doubt, use brute force.
 */
@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 ...");
    }
}

三、定义通知类

package com.aop;

public class MyAdvice {

    public void method(){
        System.out.println(System.currentTimeMillis());
    }

}

四、定义切入点

package com.aop;

public class MyAdvice {
    
    private void pt(){}

    public void method(){
        System.out.println(System.currentTimeMillis());
    }

}

tips:切入点定义依托一个不具有实际意义的方法进行,即无参数,无返回值,方法体无实际逻辑

五、绑定切入点与通知关系,并指定通知添加到原始连接点的具体执行位置

package com.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * @author : 十一
 * @data : 20:50 2022/7/30
 * When in doubt, use brute force.
 */

public class MyAdvice {

    @Pointcut("execution(void com.dao.BookDao.update())")
    private void pt(){}

    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }

}

六、定义通知类受Spring容器管理,并定义当前类为切面类

package com.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * @author : 十一
 * @data : 20:50 2022/7/30
 * When in doubt, use brute force.
 */

@Component
@Aspect
public class MyAdvice {

    @Pointcut("execution(void com.dao.BookDao.update())")
    private void pt(){}

    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }

}

七、开启Spring对AOP注解驱动支持

package com.config;

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

/**
 * @author : 十一
 * @data : 20:12 2022/7/30
 * When in doubt, use brute force.
 */
@Configuration
@ComponentScan("com.priv")
@EnableAspectJAutoProxy
public class SpringConfig {
}

1.14.3AOP工作流程


1.Spring容器启动

2.读取所有切面配置中的切入点:没有使用的不读取

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

4.获取bean执行方法

目标对象(Target):原始功能去掉共性功能对应的类产生的对象,这种对象是无法直接完成最终工作的

代理(Proxy):目标对象无法直接完成工作,需要对其进行功能回填,通过原始对象的代理对象实现


1.14.4AOP切入点表达式


20220821163800

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

execution(public User com.service.UserService.findById(int))

二、可以使用通配符描述切入点,快速描述

execution(public * com.*.UserService.find*(*))

匹配com包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

execution(public User com..UserService.findById(..))

匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

execution(* *..*Service+.*(..))

20220821165726


1.14.5AOP通知类型


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

AOP通知共分为5种类型

一、@Before

类型:方法注解

位置:通知方法定义上方

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

范例:

@Before("pt()")
public void before() {
    System.out.println("before advice ...");
}

相关属性:value(默认):切入点方法名,格式为类名.方法名()

二、@After

类型:方法注解

位置:通知方法定义上方

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

范例:

@After("pt()")
public void after() {
    System.out.println("after advice ...");
}

相关属性:value(默认):切入点方法名,格式为类名.方法名()

三、@Around

类型:方法注解

位置:通知方法定义上方

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

范例:

@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;
}

调用方法具有返回值时,around方法要将值ret返回。

注意事项

四、@AfterReturning

类型:方法注解

位置:通知方法定义上方

作用:设置当前通知方法与切入点之间的绑定关系,当前通知方法在原始切入点方法正常执行完毕后运行

范例:

@AfterReturning("pt()")
public void afterReturning() {
    System.out.println("afterReturning advice ...");
}

相关属性:value(默认):切入点方法名,格式为类名.方法名()

五、@AfterThrowing

类型:方法注解

位置:通知方法定义上方

作用:设置当前通知方法与切入点之间的绑定关系,当前通知方法在原始切入点方法运行抛出异常后执行

范例:

@AfterThrowing("pt()")
public void afterThrowing() {
    System.out.println("afterThrowing advice ...");
}

相关属性:value(默认):切入点方法名,格式为类名.方法名()


1.14.6案例:测量业务层接口执行效率


1、业务功能:业务层接口执行前后分别记录时间,求差值得到执行效率

2、通知类型选择前后均可增强的类型——环绕通知

20221215192341

ProjectAdvice.java

package com.priv.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * @author : 十一
 * @data : 19:08 2022/12/15
 * When in doubt, use brute force.
 */
@Component
@Aspect
public class ProjectAdvice {

    @Pointcut("execution(* com.priv.service.*Service.*(..))")
    private void servicePt(){

    }

    @Around("ProjectAdvice.servicePt()")
    public void runSpeed(ProceedingJoinPoint joinPoint) throws Throwable {
        Signature signature = joinPoint.getSignature();
        String name = signature.getName();
        String className = signature.getDeclaringTypeName();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            joinPoint.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("万次执行: "+ className + "." + name  + "----->" + (end - start) + "ms");
    }
}

Test

package com.priv.service;

import com.priv.config.SpringConfig;
import com.priv.domain.Account;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * @author : 十一
 * @data : 19:01 2022/12/15
 * When in doubt, use brute force.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCse {
    @Autowired
    private AccountService accountService;

    @Test
    public void testFindById(){
        Account byId = accountService.findById(2);
//        System.out.println(byId);
    }

    @Test
    public void testFindAll(){
        List<Account> all = accountService.findAll();
//        System.out.println(all);
    }
}

1.14.7AOP通知获取数据


@PointCut("execution(* com.priv.dao.BookDao.findName(..))")
private void pt(){}

@AfterReturning(value = "pt()", returing = "ret")
public void afterReturing(Object ret) {//当参数有多个时,JoinPoint必须是第一个
	System.out.println("afterReturing advice ..." + ret);
}

@AfterThrowing(value = "pt()", throwing = "t")
public void afterThrowing(Throwable t) {
	System.out.println("afterThrowing advice ..." + t);
}

1.14.8案例:百度网盘密码数据兼容处理


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

分析:

package com.priv.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * @author : 十一
 * @data : 12:25 2022/12/16
 * When in doubt, use brute force.
 */
@Component
@Aspect
public class DataAdvice {

    @Pointcut("execution(boolean com.priv.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 proceed = pjp.proceed(args);
        return proceed;
    }
}
package com.priv.config;

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

/**
 * @author : 十一
 * @data : 12:17 2022/12/16
 * When in doubt, use brute force.
 */
@Configuration
@ComponentScan("com.priv")
@EnableAspectJAutoProxy
public class SpringConfig {
}
package com.priv.dao;

/**
 * @author : 十一
 * @data : 12:18 2022/12/16
 * When in doubt, use brute force.
 */
public interface ResourcesDao {
    public boolean readResources(String url, String password);
}
package com.priv.dao.impl;

import com.priv.dao.ResourcesDao;
import org.springframework.stereotype.Repository;

/**
 * @author : 十一
 * @data : 12:18 2022/12/16
 * When in doubt, use brute force.
 */
@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        return password.equals("root");
    }
}
package com.priv.service;

/**
 * @author : 十一
 * @data : 12:19 2022/12/16
 * When in doubt, use brute force.
 */
public interface ResourcesService {
    public boolean openURL(String url, String password);
}
package com.priv.service.impl;

import com.priv.dao.ResourcesDao;
import com.priv.service.ResourcesService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author : 十一
 * @data : 12:19 2022/12/16
 * When in doubt, use brute force.
 */
@Service
public class ResourcesServiceImpl implements ResourcesService {

    @Autowired
    private ResourcesDao resourcesDao;

    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url, password);
    }
}
import com.priv.config.SpringConfig;
import com.priv.service.ResourcesService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author : 十一
 * @data : 12:19 2022/12/16
 * When in doubt, use brute force.
 */
public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService bean = annotationConfigApplicationContext.getBean(ResourcesService.class);
        boolean flag = bean.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

1.15Spring事务


1.15.1事务简介


public interface PlatformTransactionmanager{
	void commit(TransactionStatus status) throws TransactionException;
	void rollback(TransactionStatus status) throws TransactionException;
}
public class DataSourceTransactionmanager{
	...
}

案例:银行转账

20221216134720

模拟异常出现,当正常执行转账操作时:Tom减100,Jerry加100

当出现异常时,Tom减100,Jerry不变,这时就需要用到Spring事务

20221216134742 20221216134806

开启Spring事务:

1、在业务层接口中添加@Transactional

package com.priv.service;

import org.springframework.transaction.annotation.Transactional;

/**
 * @author : 十一
 * @data : 12:58 2022/12/16
 * When in doubt, use brute force.
 */
public interface AccountService {
    /**
     * 转账操作
     * @param out 转出方
     * @param in 转入方
     * @param money 金额
     */

    @Transactional
    public void transfer(String out, String in, double money);
}

在Spring配置类加@EnableTransactionManagement

package com.priv.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;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * @author : 十一
 * @data : 12:50 2022/12/16
 * When in doubt, use brute force.
 */
@Configuration
@ComponentScan("com.priv")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MybatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

1.15.2事务角色


20221216135930

20221216135953

**事务管理员:**发起事务方,在Spring中通常指代业务层开启事务的方法

**事务协调员:**加入事务方,在Spring中通常指代数据层方法,也可以是业务层方法


1.15.3事务属性


事务相关配置

20221216140415

Spring事务遇到以下两种异常进行回滚:Error系,运行时异常

如IOException就不会回滚事务:把int i = 1 / 0;换成if(true) {throw new IOException();}

解决:@Transactional(rollbackFor = {IOException.class})

案例:转账日志

要求转账记录日志,是否成功都需要记录日志

事务传播行为

事务传播行为:事务协调员对事务管理员所携带事务的处理态度

20221216142442

解决办法:log的事务单独开一个T2

在业务层接口上添加Spring事务,设置事务传播行为REQUIRES_NEW(需要新事务)

20221216142948


小结

关于SpringMVC将后续更新

相关源码请查看gitee仓库

#Spring#java#SSM