# Spring

**Repository Path**: mr_sen/Spring

## Basic Information

- **Project Name**: Spring
- **Description**: Spring学习记录
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-06-23
- **Last Updated**: 2021-06-23

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

#jdk的动态代理
> 使用流程
> 创建一个代理类（可以是工厂模式）返回一份代理对象          

```java
public class CalculaterProxy {

    public  static Calculater getProxy(Calculater calculater){
//        被代理的对象是由那个加载器加载的
        ClassLoader classLoader = calculater.getClass().getClassLoader();
//        被代理对象实现的接口
        Class<?>[] classes = calculater.getClass().getInterfaces();
//
        InvocationHandler invocationHandler = null;
        invocationHandler = new InvocationHandler() {

            @Override
            public Object invoke(
                    Object proxy,/*代理对象，共jvm使用*/
                    Method method,/*被代理对象的执行方法*/
                    Object[] args)/*被代理对象执行方法所需的参数*/throws Throwable {
                System.out.println("代理方法"+method.getName()+"执行了");
                Object result = method.invoke(calculater, args);

                return result;
            }
        };
        Calculater o = (Calculater) Proxy.newProxyInstance(classLoader, classes, invocationHandler);


        return o;
    }


}
//直接用代理类获取到要代理的对象
public class CalculaterTest {

    public static void main(String[] args) throws Exception {

        Calculater calculater = new CalculaterImpl();

        Calculater proxy = CalculaterProxy.getProxy(calculater);
        int add = proxy.add(1, 2);
        System.out.println(add);


    }
}
```
>总结：要被代理的对象一定要是一个接口。因为代理对象会通过反射获取到接口的信息，这样才能知道接口里的方法

 
# cglib的动态代理
>步骤一：动态代理类要实现MethodInterceptor接口，重写intercept方法           
> Enhancer对象创建出代理对象
```java
package com.lovexk.cglibproxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.InvocationHandler;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements /*步骤一：实现接口*/ MethodInterceptor {

    Object object;

    public CglibProxy(Object object) {
        this.object = object;
    }
/*用Enhancer创建对象*/
    public Object getProxy(){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(object.getClass());
        enhancer.setCallback(this);

        Object o = enhancer.create();
        return o;


    }

    @Override /*步骤二：实现方法*/
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

            /* 这两种形式都可以执行代理方法*/
//        Object invoke = method.invoke(object, objects);
        Object invoke = methodProxy.invoke(object, objects);

        return invoke.toString()+" 小情绪！";

    }
}
```
# 事务
> 脏读：读取到了其他线程(事务没有提交的数据)，这个数据可能回滚了                        
> 不可重复读：同一个事务获取到了不同的结果
> 
##隔离级别
>Read uncommitted 、读未提交（可以读取未提交的数据）                           
> Read committed 、读已提交（同一个事务中可以读取已经提交的数据）                                
> Repeatable read  可重复读（确保Transaction01可以多次从一个字段中读取到相同的值，                        
>                       即Transaction01执行期间禁止其它事务对这个字段进行更新）                       
> Serializable
>