三、AOP

1. 底层原理

面向切面编程，利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。通俗来说就是在不修改代码的情况下添加新的功能。

底层通过动态代理来实现：

第一种：有接口的情况，使用JDK动态代理：创建接口实现类的代理对象。

第二种：无接口的情况，使用CGLIB动态代理：创建当前类子类的代理对象。 JDK动态代理举例：

通过 java.lang.reflect.Proxy类的 newProxyInstance方法创建代理类。

newProxyInstance方法：

参数一：类加载器

参数二：所增强方法所在的类，这个类实现的接口，支持多个接口

参数三：实现InvocationHandle接口，重写invoke方法来添加新的功能

代码举例：

public interface UserDao {
    public int add(int a, int b);
    public int multi(int a, int b);
}

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

public class Main {
    @Test
    public void test1(){
        //所需代理的类实现的接口，支持多个接口
        Class[] interfaces = {UserDao.class};
        UserDao userDao = new UserDaoImpl();
    //调用newProxyInstance方法来创建代理类
        UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(Main.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int result = userDaoProxy.add(1, 2);
        System.out.println(result);
    }
    //创建内部类，实现InvocationHandler接口，重写invoke方法，添加新功能
    class UserDaoProxy implements InvocationHandler {
        Object obj;
    //通过有参构造函数将所需代理的类传过来
        public UserDaoProxy(Object obj){
            this.obj = obj;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("进入" + method.getName() + "方法，这是新增的代码，参数有" + Arrays.toString(args));
      //执行原有的代码
            Object invoke = method.invoke(obj, args);
            System.out.println("方法原先的内容执行完了");
            return invoke;
        }
    }
}

2. 基于AspectJ实现AOP操作

（1）AOP相关术语：

连接点：类中可以被增强的方法，称为连接点。

切入点：实际被增强的方法，称为切入点。

通知：增强的那一部分逻辑代码。通知有多种类型：

前置通知：增强部分代码在原代码前面。

后置通知：增强部分代码在原代码后面。

环绕通知：增强部分代码既有在原代码前面，也有在原代码后面。

异常通知：原代码发生异常后才会执行。

最终通知：类似与finally那一部分

切面：指把通知应用到切入点这一个动作。

网络异常，图片无法展示

（2）基于AspectJ实现AOP有两种方式：

基于xml配置文件基于注解方法

（3）切入点表达式

语法：execution（[权限修饰符] [返回类型] [类全路径] [方法名称] [参数列表]）

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

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

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

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

举例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强

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

（1）基于注解方式

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

@Component
@Aspect   //使用Aspect注解
public class UserProxy {
    //前置通知
    @Before(value="execution(* com.oymn.spring5.User.add(..))")
    public void before(){
        System.out.println("UserProxy.before()");
    }
    //后置通知
    @AfterReturning(value="execution(* com.oymn.spring5.User.add(..))")
    public void afterReturning(){
        System.out.println("UserProxy.afterReturning()");
    }
    //最终通知
    @After(value="execution(* com.oymn.spring5.User.add(..))")
    public void After(){
        System.out.println("UserProxy.After()");
    }
    //异常通知
    @AfterThrowing(value="execution(* com.oymn.spring5.User.add(..))")
    public void AfterThrowing(){
        System.out.println("UserProxy.AfterThrowing()");
    }
    //环绕通知
    @Around(value="execution(* com.oymn.spring5.User.add(..))")
    public void Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("UserProxy.Around()   _1");
        //调用proceed方法执行原先部分的代码
        proceedingJoinPoint.proceed();
        System.out.println("UserProxy.Around()   _2");
    }
}

配置xml文件：

<!--开启组件扫描-->
<context:component-scan base-package="com.oymn"></context:component-scan>
<!--开启AspectJ生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

测试类：

@Test
public void test2(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    User user = context.getBean("user", User.class);
    user.add();
}

运行结果中没有出现异常通知，在add方法中添加int i = 1/0;

public void add(){
    int i = 1/0;
    System.out.println("User.add()");
}

运行结果：从这里也可以看到，但出现异常时，After最终通知有执行，而AfterReturning后置通知并没有执行。

对于上面的例子，有很多通知的切入点都是相同的方法，因此，可以将该切入点进行抽取：通过@Pointcut注解

@Pointcut(value="execution(* com.oymn.spring5.User.add(..))")
public void pointDemo(){
}
//前置通知
@Before(value="pointDemo()")
public void before(){
    System.out.println("UserProxy.before()");
}

设置增强类优先级：

当有多个增强类对同一方法进行增强时，可以通过 @Order（数字值）来设置增强类的优先级，数字越小优先级越高。

@Aspect
@Order(1)
public class PersonProxyva
@Component
@Aspect
@Order(1)
public class PersonProxy

完全注解开发：

可以通过配置类来彻底摆脱xml配置文件：

@Configuration
@ComponentScan(basePackages = "com.oymn.spring5")
//@EnableAspectJAutoProxy注解相当于上面xml文件中配置的 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
@EnableAspectJAutoProxy(proxyTargetClass = true)  
public class Config {
}

（2）基于xml方式

这种方式开发中不怎么用，了解即可。

创建Book和BookProxy类

public class Book {
    public void buy(){
        System.out.println("buy()");
    }
}

public class BookProxy {
    public void before(){
        System.out.println("before()");
    }
}

配置xml文件：

<!--创建对象-->
    <bean id="book" class="com.oymn.spring5.Book"></bean>
    <bean id="bookProxy" class="com.oymn.spring5.BookProxy"></bean>
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.oymn.spring5.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <aop:before method="before" pointcut-ref="p"/>  <!--将bookProxy中的before方法配置为切入点的前置通知-->
        </aop:aspect>
    </aop:config>

四、JdbcTemplate

Spring对JDBC进行封装，使用JdbcTemplate方便对数据库的操作。（1）增删改操作：

int update(String sql, Object... args);

（2）查询：返回某个值

T queryForObject(String sql,Class<T> requiredType);

（3）查询：返回某个对象

T queryForObject(String sql,RowMapper<T> rowMapper,Object ... args);

（4）查询：返回集合

List<T> query(String sql,RowMapper<T> rowMapper,Object... args);

（5）批量增删改：

int[] batchUpdate(String sql,List<Object[]> batchArgs);

举例：

引入相关jar包

配置数据库连接池；配置JdbcTemplate对象

<context:component-scan base-package="com.oymn"></context:component-scan>
    <!--配置数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="url" value="jdbc:mysql://localhost:3306/book" />
        <property name="username" value="root" />
        <property name="password" value="000000" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>
    <!--创建JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入数据库连接池-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

创建Service类和Dao类，在Dao类中注入JdbcTemplate对象

public interface BookDao {
        public void add(Book book);  //添加图书
        public void update(Book book);  //修改图书
        public void delete(int id);  //删除图书
        public int queryCount();   //查询数量
        public Book queryBookById(int id);  //查询某本书
        public List<Book> queryBooks();   //查询所有书
        public void batchAddBook(List<Object[]> books);  //批量添加图书
        public void batchUpdateBook(List<Object[]> books);  //批量修改图书
        public void batchDeleteBook(List<Object[]> args);  //批量删除图书
    }

@Repository
public class BookDaoImpl implements BookDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public void add(Book book) {
        String sql = "insert into t_book set name=?,price=?";
        Object[] args = {book.getBookName(),book.getBookPrice()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }
    @Override
    public void update(Book book) {
        String sql = "update t_book set name=?,price=? where id=?";
        Object[] args = {book.getBookName(),book.getBookPrice(),book.getBookId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }
    @Override
    public void delete(int id) {
        String sql = "delete from t_book where id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }
    @Override
    public int queryCount() {
        String sql = "select count(*) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }
    @Override
    public Book queryBookById(int id) {
        String sql = "select id bookId,name bookName,price bookPrice from t_book where id=?";
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }
    @Override
    public List<Book> queryBooks() {
        String sql = "select id bookId,name bookName,price bookPrice from t_book";
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
        return bookList;
    }
    @Override
    public void batchAddBook(List<Object[]> books) {
        String sql = "insert into t_book set id=?,name=?,price=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, books);
        System.out.println(ints);
    }
    @Override
    public void batchUpdateBook(List<Object[]> books) {
        String sql = "update t_book set name=?,price=? where id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, books);
        System.out.println(ints);
    }
    @Override
    public void batchDeleteBook(List<Object[]> args) {
        String sql = "delete from t_book where id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, args);
        System.out.println(ints);
    }
}

@Service
public class BookService {
    @Autowired
    private BookDao bookDao = new BookDaoImpl();
    //添加图书
    public void add(Book book){
        bookDao.add(book);
    }
    //修改图书
    public void update(Book book){
        bookDao.update(book);
    }
    //删除图书
    public void delete(Integer id){
        bookDao.delete(id);
    }
    //查询数量
    public int queryCount(){
        return bookDao.queryCount();
    }
    //查询图书
    public Book queryBookById(Integer id){
        return bookDao.queryBookById(id);
    }
    //查询所有图书
    public List<Book> queryBooks(){
        return bookDao.queryBooks();
    }
    //批量添加图书
    public void batchAddBook(List<Object[]> books){
        bookDao.batchAddBook(books);
    }
    //批量修改图书
    public void batchUpdateBook(List<Object[]> books){
        bookDao.batchUpdateBook(books);
    }
    //批量删除图书
    public void batchDeleteBook(List<Object[]> args){
        bookDao.batchDeleteBook(args);
    }
}

五、事务管理

事务是数据库操作最基本单位，要么都成功，要么都失败。

典型场景：转账

事务四个特性ACID：原子性，一致性，隔离性，持久性。

Spring事务管理有两种方式：编程式事务管理和声明式事务管理，一般使用声明式事务管理，底层使用AOP原理。

声明式事务管理有两种方式：基于xml配置方式和基于注解方式，一般使用注解方式。

Spring事务管理提供了一个接口，叫做事务管理器，这个接口针对不同的框架提供不同的实现类。

对于使用JdbcTemplate进行数据库交互，则使用DataSourceTransactionManager实现类，如果整合Hibernate框架则使用HibernateTransactionManager实现类，具体情况具体使用。

（1）注解实现声明式事务管理：

<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/book" />
    <property name="username" value="root" />
    <property name="password" value="000000" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>
<!--创建JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入数据库连接池-->
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

在service类上面或者service类的方法上面添加事务注解@Transactional

如果把@Transactional添加在类上面，这个类里面所有方法都添加事务。如果只是添加在方法上面，则只为这个方法添加事务。

@Service
@Transactional
public class UserService {}

声明式事务管理的参数配置：

propagation：事务传播行为，总共有7种，这一块讲的不是很清楚

isolation：事务隔离级别

有三个读问题：脏读，不可重复读，虚读（幻读）。

设置隔离级别，解决读问题：

脏读不可重复读虚读 READ UNCOMMITED（读未提交）有有有 READ COMMITED（读已提交）无有有 REPEATABLE READ（可重复读）无无有 SERIALIZABLE（串行化）无无无 timeout：超时时间

事务需要在一定时间内进行提交，超过时间后回滚。默认值是-1，设置时间以秒为单位。 readOnly：是否只读默认值为false，表示可以查询，也可以增删改。设置为true，只能查询。 rollbackFor：回滚，设置出现哪些异常进行事务回滚。

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

@Service
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.READ_COMMITTED)
public class AccountService {}

完全注解实现声明式事务管理：

配置类：

@Configuration  //配置类
@ComponentScan(basePackages = "com.oymn.spring5")  //开启组件扫描
@EnableTransactionManagement  //开启事务
public class Config {
    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/book");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("000000");
        return druidDataSource;
    }
    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

@Service
public class AccountService {
    @Autowired
    private AccountDao accountDao;
    @Transactional
    public void accountMoney(){
        accountDao.add();
        //int i=1/0;   //用来模拟转账失败
        accountDao.reduce();
    }
}

（2）xml实现声明式事务管理：

<context:component-scan base-package="com.oymn"></context:component-scan>
<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
      destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/book" />
    <property name="username" value="root" />
    <property name="password" value="000000" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>
<!--创建JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入数据库连接池-->
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!--配置事务通知-->
<tx:advice id="txadvice">
    <!--配置事务参数-->
    <tx:attributes>
        <tx:method name="accountMoney" propagation="REQUIRED" />
    </tx:attributes>
</tx:advice>
<!--配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.oymn.spring5.Service.*.*(..))"/>
    <!--配置切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

六、Spring5新特性

自带了日志封装 Spring5移除了Log4jConfigListener，官方建议使用Log4j2 Spring5整合Log4j2：

第一步：引入jar包

第二步：创建log4j2.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
    <!--先定义所有的appender-->
    <appenders>
        <!--输出日志信息到控制台-->
        <console name="Console" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

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

@Nullable     //表示方法返回值可以为空
public int getId();
@Nullable     //表示参数可以为空
public void setId(@Nullable int Id);
@Nullable     //表示属性可以为空
public int id;

支持函数式风格编程这是因为java8新增了lamda表达式

@Test
    public void test() {
        //1 创建 GenericApplicationContext 对象
        GenericApplicationContext context = new GenericApplicationContext();
        //2 调用 context 的方法对象注册
        context.refresh();
        context.registerBean("user1",User.class,() -> new User());
        //3 获取在 spring 注册的对象
        // User user = (User)context.getBean("com.atguigu.spring5.test.User");
        User user = (User)context.getBean("user1");
        System.out.println(user);
    }

支持整合JUnit5 （1）整合JUnit4：

第一步：引入jar包

第二步：创建测试类，使用注解方式完成

@RunWith(SpringJUnit4ClassRunner.class) //单元测试框架
    @ContextConfiguration("classpath:bean4.xml") //加载配置文件
    public class JUnitTest {
        @Autowired
        public User user;
        @Test
        public void test(){
            System.out.println(user);
        }
    }

bean4.xml：

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

通过使用@ContextConfiguration注解，测试方法中就不用每次都通过context来获取对象了，比较方便。

ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
BookService bookService = context.getBean("bookService",BookService.class);

Spring 5笔记（下）

三、AOP

1. 底层原理

2. 基于AspectJ实现AOP操作

（1）基于注解方式

（2）基于xml方式

四、JdbcTemplate

五、事务管理

六、Spring5新特性

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Spring 5笔记（下）

三、AOP

1. 底层原理

2. 基于AspectJ实现AOP操作

（1）基于注解方式

（2）基于xml方式

四、JdbcTemplate

五、事务管理

六、Spring5新特性

热门文章

最新文章

相关课程

相关电子书

相关实验场景