Spring5(二)AOP及其他

微微微微微凉、

已于 2022-09-22 20:28:11 修改

阅读量154

点赞数

文章标签：散列表

于 2022-03-28 21:17:00 首次发布

本文链接：https://blog.csdn.net/weixin_46163707/article/details/123798767

版权

@Configuration//标志该文件将代替xml作为配置文件
@ComponentScan(basePackages = {"com.atguigu"})//开启扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启事务
public class SpringConfig {
    ///创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("${jdbc.driver}");
        dataSource.setUrl("jdbc:mysql://localhost:3306/t_account?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false&rewriteBatchedStatements=true");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;

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



}

@Test
    public void test3(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean("user", User.class);
        user.add();

    }

<dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.6.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>






    </dependencies>

1、在 service 类上面（或者 service 类里面方法上面）添加事务注解

2.事务操作（声明式事务管理参数配置）

一、AOP

1.什么是AOP-aspect oriented programming

（1）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

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

2.AOP的底层原理

1、AOP 底层使用动态代理

有两种情况的动态代理

2、JDK 动态代理

调用 newProxyInstance 方法，这个方法返回的是Object类型，需要强转一下类型

方法有三个参数：

第一参数，类加载器

第二参数，增强方法所在的类，这个类实现的接口，支持多个接口，是一个数组类型

第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

public class JDKProxy {
    @Test
    public void proxyTest(){
        Class[] interfaces={UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        dao.add();
    }
}

public class UserDaoProxy implements InvocationHandler {
    Object obj;
    public UserDaoProxy(Object obj) {
        this.obj=obj;
    }


//invoke方法中如果不对method进行判断就是，对obj类中的所有方法进行增强

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前
        System.out.println("之前的操作");
        //增强的方法
        Object res = method.invoke(obj, args);
        //方法之后
        System.out.println("之后的操作");
        return res;
    }
}

3、AOP（术语）

（1）连接点：类中可以被被增强的方法叫连接点

（2）切入点：类中实际被增强的方法叫切入点

（3）通知/增强：实际增强的逻辑部分

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

通知的分类（以上面增强add()方法为例）

前置通知：注解是@Before add()之前执行的通知

后置通知：注解是@AfterReturning add()之后执行的通知，add()出现异常就不会执行的通知

环绕通知：注解是@Around add()前后都会执行的通知

异常通知：注解是@AfterThrowing 有异常时才会执行的通知

最终通知：注解是@After 类似于finally，不管有没有异常都会执行的通知

4、切入点表达式

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

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

权限修饰符：用 * 表示所有的权限修饰符P

返回类型可以省略不写

[类全路径] [方法名称] 连在一起写;特别的该类中所有方法用*，举例2和3

参数列表固定写法：(..)

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

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

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

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

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

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

（2）使用方法

举例@Before(value = "execution(* com.atguigu.dao.BookDao.add(..))")

5、AOP操作

（1）Spring 框架一般都是基于 AspectJ 实现 AOP 操作，在项目工程里面引入 AOP 相关依赖

（2）完全注解开发的配置文件

@Configuration//标志该文件将代替xml作为配置文件
@ComponentScan(basePackages = {"com.atguigu"})//开启扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启AOP
public class SpringConfig {
//接下来数数据库的配置
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("${jdbc.driver}");
        dataSource.setUrl("jdbc:mysql://localhost:3306/t_account?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false&rewriteBatchedStatements=true");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;

    }
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        //到 ioc 容器中根据类型找到 dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入 dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }


}

（3）

增强类于被增强类都需要注解@Component/@Service/...

增强类需要注解@Aspect

@Component
public class User {

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

@Component
@Aspect
public class UserProxy {
    @Before(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
    public void before(){
        System.out.println("前置通知...");
    }
    @Around(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知1...");
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知2...");
    }
    @AfterReturning(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
    public void afterReturning(){
        System.out.println("后置通知.....");
    }
    @AfterThrowing(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
    public void afterThrowing(){
        System.out.println("异常通知....");
    }

    @After(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
    public void after(){
        System.out.println("最终通知...");
    }
}

(4) 优化：(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")重复出现

//相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {
}
//前置通知
//@Before 注解表示作为前置通知
@Before(value = "pointdemo()")
public void before() {
 System.out.println("before.........");
}

//优化后
@Component
@Aspect

public class UserProxy {
    @Pointcut(value = "execution(* com.atguigu.spring5.Proxy.User.add(..))")
    public void pointCut(){}
    @Before(value = "pointCut()")
    public void before(){
        System.out.println("前置通知...");
    }
    @Around(value = "pointCut()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知1...");
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知2...");
    }
    @AfterReturning(value = "pointCut()")
    public void afterReturning(){
        System.out.println("后置通知.....");
    }
    @AfterThrowing(value = "pointCut()")
    public void afterThrowing(){
        System.out.println("异常通知....");
    }

    @After(value = "pointCut()")
    public void after(){
        System.out.println("最终通知...");
    }
}

（5）有多个增强类多同一个方法进行增强，设置增强类优先级

在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

@Component

@Aspect

@Order(1)

public class PersonProxy{}

(6)测试

@Test
    public void test3(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean("user", User.class);
        user.add();

    }

二、JdbcTemplate

1.什么是 JdbcTemplate

Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

2.API

(1):添加，删除，修改：update( String sql,Object. .. args)

(2)查询返回某个值：queryForObject(String sql，Class<T> requiredType)

第二个参数 Class<T> requiredType

这个参数指的是你要的返回类型，你要integer类型就写Integer.class

___.class ___写的是类名

____.getclass ____写的是对象名

//查询表记录数
@Override
public int selectCount() {
     String sql = "select count(*) from t_book";
     Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
     return count;
}

(2):查询返回单个对象：queryForObject ( String sql,RowMapper<T> rowMapper,Object. .. args)

有三个参数

第一个参数：sql 语句

第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装

第三个参数：sql 语句值

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

(3)查询返回集合：query ( String sql,RowMapper<T> rowMapper,Object. .. args)

有三个参数

第一个参数：sql 语句

第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装

第三个参数：sql 语句值

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

（4）实现批量添加操作：batchUpdate( String sql， List<0bject[]> batchArgs)

返回一个数组，长度是batchArgs的长度

有两个参数

第一个参数：sql 语句

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

//添加
@Override
public void batchAddBook(List<Object[]> batchArgs) {
 String sql = "insert into t_book values(?,?,?)";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));
}
//批量添加测试
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3","java","a"};
Object[] o2 = {"4","c++","b"};
Object[] o3 = {"5","MySQL","c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
bookService.batchAdd(batchArgs);

//批量修改
@Override
public void batchUpdateBook(List<Object[]> batchArgs) {
 String sql = "update t_book set username=?,ustatus=? where user_id=?";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));
}
//批量修改
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"java0909","a3","3"};
Object[] o2 = {"c++1010","b4","4"};
Object[] o3 = {"MySQL1111","c5","5"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用方法实现批量修改
bookService.batchUpdate(batchArgs);

//批量删除
@Override
public void batchDeleteBook(List<Object[]> batchArgs) {
 String sql = "delete from t_book where user_id=?";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));
}
//批量删除
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3"};
Object[] o2 = {"4"};
batchArgs.add(o1);
batchArgs.add(o2);
//调用方法实现批量删除
bookService.batchDelete(batchArgs);

三、事务

1、在 service 类上面（或者 service 类里面方法上面）添加事务注解

（1）@Transactional，这个注解添加到类上面，也可以添加方法上面

（2）如果把这个注解添加类上面，这个类里面所有的方法都添加事务

（3）如果把这个注解添加方法上面，为这个方法添加事务

@Service
@Transactional
public class UserService {}

2.事务操作（声明式事务管理参数配置）

1）、在 service 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数

2）、propagation：事务传播行为：一个有事务调用一个无事务/一个有事务调用一个有事务/一个无事务调用一个有事务/一个无事务调用一个有事务

如下面 add是有事务，update是无事务，add调用update就是事务传播行为

事务的传播行为有7种，如何写（见下）

@Service
@Transactional(propagation = Propagation.REQUIRED)
public class AccountServiceImpl implements AccountService {

下面两种传播行为比较重要

3）、ioslation：事务隔离级别

（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

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

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

（4）不可重复读：一个未提交事务读取到另一提交事务修改数据

（5）虚读：一个未提交事务读取到另一提交事务添加数据

（6）解决：通过设置事务隔离级别，解决读问题

4）、timeout：超时时间（1）事务需要在一定时间内进行提交，如果不提交进行回滚（2）默认值是 -1 ，设置时间以秒单位进行计算

5）、readOnly：是否只读（1）读：查询操作，写：添加修改删除操作（2）readOnly 默认值 false，表示可以查询，可以添加修改删除操作（3）设置 readOnly 值是 true，设置成 true 之后，只能查询

6）、rollbackFor：回滚（1）设置出现哪些异常进行事务回滚

7）、noRollbackFor：不回滚（1）设置出现哪些异常不进行事务回滚

微微微微微凉、

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring5(二)AOP及其他

@Configuration//标志该文件将代替xml作为配置文件@ComponentScan(basePackages = {"com.atguigu"})//开启扫描@EnableAspectJAutoProxy(proxyTargetClass = true)//开启事务public class SpringConfig { ///创建数据库连接池 @Bean public DruidDataSource getDruidDataSource() { D.
复制链接

扫一扫