Spring---Aop

Spring Aop介绍：

1.Aop介绍
    Spring Aop是面向切面编程，底层是动态代理。可以实现在不改变源码的情况下，对目标方法进行增强。
Spring Aop支持声明式事务，与编程式事务相比较，声明式事务最大的优点就是不需要通过编程的方式管
理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过
基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。
    
    Spring Aop的典型使用场景：
        1.事务管理；
        2.日志记录；
        3.权限控制

2.Spring Aop术语：
        JoinPoint: 连接点：
            所有的方法都可以是连接点；
        Pointcut: 切入点：
            需要进行增强的方法就是切入点；
        Advice: 通知/增强 ：
            增强的逻辑就是通知，通知需要切入到切入点中；
            通知分为：
                前置通知；
                后置通知；
                环绕通知；
                异常通知；
                最终通知；
        Aspect: 切面：
            切入点和通知的结合就是切面；
            
3.Aop的使用：
    1.创建工程，导入坐标依赖：
        
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
            4.0.0com.it
            spring-aop
            1.0-SNAPSHOTorg.springframework
                    spring-context
                    5.0.2.RELEASEorg.aspectj
                    aspectjweaver
                    1.8.7org.springframework
                    spring-test
                    5.0.2.RELEASEjunit
                    junit
                    4.12test
    
    2.创建Dao接口，定义方法；
        public interface AccountDao {

            void save();

            Object delete();

            void findAll();

            void update();

            void findById();
        }
        
    3.创建Dao接口的实现类，重写接口方法（在这里，这些方法就是需要进行增强的方法）
        public class AccountDaoImpl implements AccountDao {
            public void save() {
                System.out.println("save....");
            }

            public Object delete() {
                System.out.println("delete....");
                return "success";
            }

            public void findAll() {
                //模拟耗时
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("findAll...");
            }

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

            public void findById() {
                System.out.println("findById.....");
                int i=1/0;
            }
        }
        
    4.创建切面类，类中定义增强逻辑方法：
        public class MyAspect {

            //前置通知，增强逻辑
            public void check(){
                System.out.println("权限校验。。。");
            }
            //后置通知，增强逻辑
            public void log(Object obj){
                System.out.println("日志记录。。。"+obj);
            }
            //环绕通知，增强逻辑
            public void showTime(ProceedingJoinPoint joinPoint) throws Throwable {
                //目标方法调用之前
                System.out.println("调用之前的时间："+System.currentTimeMillis());
                //调用目标方法
                joinPoint.proceed();
                //目标方法调用之后
                System.out.println("调用之后的时间："+System.currentTimeMillis());

            }
            //异常通知，增强逻辑
            public void throwException(Exception e){
                System.out.println("异常抛出通知========"+e.getMessage());
            }

            //最终通知，增强逻辑
            public void showFinal(){
                System.out.println("最终通知。。。");
            }

        }
        
    5.配置文件:
        在配置文件中注册Dao实现类和切面类；
        在配置文件中配置aop，在aop中配置切入点和切面，在切面中配置通知；
        
        
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
               xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
            
            class="com.it.dao.impl.AccountDaoImpl">class="com.it.aspect.MyAspect">
        
    6.编写测试：
        RunWith(SpringJUnit4ClassRunner.class)
        @ContextConfiguration(value = "classpath:applicationContext.xml")
        public class Test {

            @Autowired
            private AccountDao accountDao;

            @org.junit.Test
            public void fun(){
                accountDao.save();
            }

            @org.junit.Test
            public void fun02(){
                accountDao.delete();
            }

            @org.junit.Test
            public void fun03(){
                accountDao.findAll();
            }

            //测试异常通知
            @org.junit.Test
            public void fun04(){
                accountDao.update();
            }

            //测试最终通知
            @org.junit.Test
            public void fun05(){
                accountDao.findById();
            }


        }