my-spring-learing(AOP)

AOP

就是把一些功能封装起来，比如日记功能，我把它封装起来，到时候插入到计算器中的加减乘除中，实现日记功能，而不是把日记功能插入到计算中去，又有计算又有日记的一堆代码。

非核心关注点拿出去

aop配置

　　 <!-- 组件扫描 -->
    <context:component-scan base-package="AOP"></context:component-scan>
    <!-- 基于注解的AspectJ，加这个配置的原因是—到时候的切面插入的时候，会用到代理类，这个配置的目的就是自动生成代理类 -->
    <aop:aspectj-autoproxy />

先声明一个切面，切面中主要变成对象就是通知(各个具体的工作)

　　main.java
　　public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("AOP/AspectJ.xml");
        caculate cau = ctx.getBean("caculateImpl",caculate.class);
        /*
        由于在@Before("execution(public int AOP.caculateImpl.add(int,int))")，这里有声明对它的一个切面的代理，所以aspectJ会自动生成代理对象，
         这里的取值是代理对象，而不是原来对象。
         System.out.println(cau.getClass().getName()); 结果是com.sun.proxy.$Proxy13，是一个动态代理
         */
        System.out.println(cau.add(1,2));
    }
切面类.java

@Component
@Aspect
public class AspectLearn {
    /*
    前置通知
     */
    @Before("execution(public int AOP.caculateImpl.add(int,int))")
    public void BeforeMethod(){
        System.out.println("切入表达式");
    }
}

xml配置文件

<!-- 组件扫描 -->
<context:component-scan base-package="AOP"></context:component-scan>
<!-- 基于注解的AspectJ，加这个配置的原因是—到时候的切面插入的时候，会用到代理类，这个配置的目的就是自动生成代理类 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

得到此时连接点的信息

@Component
@Aspect
public class AspectLearn {
    /*
    切入点表达式
     */
    @Pointcut("execution(public int AOP.caculateImpl.add(int,int))")
    public  void myPointCut(){}
    /*
    前置通知
     */
    @Before("myPointCut()")
    public void BeforeMethod(){
        System.out.println("切入表达式，方法开始执行");
    }
    /*
    返回通知
    不管方法是否正常执行，都执行这个操作
     */
    @After("execution(* AOP.*.*(..))")
    public  void After(JoinPoint joinPoint){
        String methdName = joinPoint.getSignature().getName();
        System.out.println("方法执行结束");
    }
    /*
    返回通知，得到执行结果
        returning = "result",这里的名字与下面函数的形参名字必须一样，这样就能将结果、传进去
        方法的返回值这时候就给了result
     */
    @AfterReturning(value = "execution(* AOP.*.*(..))",returning = "result")
    public  void AfterReturning(JoinPoint joinPoint,Object result){
        String methdName = joinPoint.getSignature().getName();
        System.out.println("方法"+methdName+" 的结果是 "+result);
    }
    /*
    异常通知
     */
    @AfterThrowing(value = "execution(* AOP.*.*(..))",throwing = "ex")
    public void Throw(JoinPoint joinPoint,Exception ex){
        String methdName = joinPoint.getSignature().getName();
        System.out.println("方法"+methdName+" 的异常是 "+ex);
    }

环绕通知一般不与其他的一起使用 

 

切面执行顺序 

　　重用切入点表达式
　　/*
    切入点表达式
     */
    @Pointcut("execution(public int AOP.caculateImpl.add(int,int))")
    public  void myPointCut(){}
    /*
    前置通知
     */
    @Before("myPointCut()")
    public void BeforeMethod(){
        System.out.println("切入表达式，方法开始执行");
    }

<!-- 目标对象 -->
    <bean id="caculateImpl" class="xml_set_qiemian.caculateImpl"></bean>
    <!-- 切面 此时它只是一个bean对象，需要进行配置才可以是其切面-->
    <bean id="aspectLearn" class="xml_set_qiemian.AspectLearn"></bean>
    <!-- AOP  关注点是:切面 通知 切入点表达式-->
    <aop:config>
        <aop:aspect ref="aspectLearn" order="1"><!-- order就是多个切面优先级，越小越优先，做大值是21473647 -->
            <!-- 切入点表达式 -->
            <aop:pointcut id="myPointcut" expression="execution(* xml_set_qiemian.*.*(..))"/>
            <!-- 通知，通过配置切入进去。(aspectLearn 类中的对应方法写到对应method中即可) ref是引用的意思-->
            <aop:before method="BeforeMethod" pointcut-ref="myPointcut"/>
            <aop:after method="After" pointcut="execution(* xml_set_qiemian.*.*(..))"/><!-- 这样写也行 -->
            <aop:after-returning method="AfterReturning" pointcut-ref="myPointcut" returning="result"/>
            <aop:after-throwing method="Throw" pointcut-ref="myPointcut" throwing="ex"/>
            <!-- <aop:around method=""/> -->
        </aop:aspect>

    </aop:config>

spring下面的增删改查操作

首先获取数据库连接

 

 

 

 框架的便捷之处

 便捷

 mybaties好像可以直接进行事务操作，比这个spring框架下面的更加简单。

当一些操作必须都执行完才结束，需要用到事务管理器

管理起来

三个操作管理起来，同时发生或者同时不发生。 

事务锁的参数值 

 数据库事务隔离级别

1 读未提交  脏读 ->a把50改为30，此时b读取数据是30，但是a反悔了撤销修改为50，但是b读取的是30.
2 读已提交  不可重复读 ->a准备修改的时候b读取数据50，a修改之后b又过来读取发现变成了30，不可重复读，强调修改，一般的都是这个
4 课重复读  幻读 ->a修改的时候b不可以读取，在a修改完之后c插入了一条数据，此时b过来读取的时候发现有数据了，强调插入，mysql是这个
8 串行化  一个人用别人都不能用，厕所关了小单间就行但是把大门关了，效率低

事务也可以设置不回滚

 

 

事务有超时设置

timeout  = 3，这个也是参数里面的，有可能事务卡住了