3-春AOP

AOP

1 - AOPとは何ですか

AOPアスペクト指向プログラミング指向プログラミング
AOPは、従来の縦方向の連続反復符号化システム（パフォーマンス監視、トランザクション管理、セキュリティチェック、キャッシュ）を交換横断抽出機構を取ら。

実装の原則を基礎となる2 AOP

3-AOP関連の用語

public class USerDaoImpl implements UserDao{
    public void save(User user){
    
    }
    public void update(User user){
    
    }
    public void find( ){
    
    }
    public void delete(User user){
    
    }
}

ジョインポイントは、（接続点）：傍受することができる点を指します。CRUDこれらの方法は、向上させることができ、これらの方法は、結合点と呼ばれています。

ポイントカット（エントリポイント）：ブロックされた本当のポイントを指します。ただ、エントリ・ポイントと呼ばれ、（許可をチェックします）強化の方法を保存する方法を保存したいです。

アドバイス（通知）：DOを傍受した後。校正方法を保存する方法には、チェックする通知許可と呼ばれます。

ターゲット（目標）：強化されたオブジェクト

ウィービング（織り）：対象のアドバイスに適用される手順。UserDaoImplのSaveメソッドの処理に適用する権限を確認してください。

プロキシ（エージェント）：プロキシオブジェクトをもたらす、適用された後に増強しました。

（セクション）の態様は：エントリーポイントと通知の組み合わせです。

4.JDK動的プロキシ

テストのjarパッケージをインポートする必要があるコードを変更Juint

public interface UserDao {
    public void save();

    public void update();

    public void delete();

    public void find();
}

* * *
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("保存用户...");
    }

    public void update() {
        System.out.println("修改用户...");
    }

    public void delete() {
        System.out.println("删除用户...");
    }

    public void find() {
        System.out.println("查询用户...");
    }
}

* * *
public class MyJdkProxy implements InvocationHandler{
    private UserDao userDao;

    public MyJdkProxy(UserDao userDao){
        this.userDao = userDao;
    }

    public Object createProxy(){
        Object proxy = Proxy.newProxyInstance(userDao.getClass().getClassLoader(),userDao.getClass().getInterfaces(),this);
        return proxy;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("save".equals(method.getName())){
            System.out.println("权限校验...");
            return method.invoke(userDao,args);
        }
        return method.invoke(userDao,args);
    }
}

* * *
public class SpringDemo1 {
    @Test
    public void demo1(){
        UserDao userDao = new UserDaoImpl();

        UserDao proxy = (UserDao)new MyJdkProxy(userDao).createProxy();
        proxy.save();
        proxy.update();
        proxy.delete();
        proxy.find();
    }
}

5.生成されたプロキシCGLIB

pom.xml核心jar包
<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
     <!--aop联盟的包-->
    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
    <!--spring aop的包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

public class ProductDao {
    public void save(){
        System.out.println("保存商品...");
    }

    public void update(){
        System.out.println("修改商品...");
    }

    public void delete(){
        System.out.println("删除商品...");
    }

    public void find(){
        System.out.println("查询商品...");
    }
}

* * *
public class MyCglibProxy implements MethodInterceptor{

    private ProductDao productDao;

    public MyCglibProxy(ProductDao productDao){
        this.productDao = productDao;
    }

    public Object createProxy(){
        // 1.创建核心类
        Enhancer enhancer = new Enhancer();
        // 2.设置父类
        enhancer.setSuperclass(productDao.getClass());
        // 3.设置回调
        enhancer.setCallback(this);
        // 4.生成代理
        Object proxy = enhancer.create();
        return proxy;
    }

    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        if("save".equals(method.getName())){
            System.out.println("权限校验===================");
            return methodProxy.invokeSuper(proxy,args);
        }
        return methodProxy.invokeSuper(proxy,args); //调用父类
    }
}

* * *
public class SpringDemo2 {

    @Test
    public void demo1(){
        ProductDao productDao = new ProductDao();

        ProductDao proxy = (ProductDao) new MyCglibProxy(productDao).createProxy();
        proxy.save();
        proxy.update();
        proxy.delete();
        proxy.find();
    }
}

6-エージェント知識の要約

実行時に1 - 春、動的プロキシオブジェクトを生成し、特別なコンパイラ

2スプリングAOP根底にある目的は、豆JDK動的プロキシであるか、または動的プロキシ技術CGLIBによって
横製織を行います。

ターゲット・オブジェクトがインターフェースの数を実装する場合、スプリングjava.lang.reflect.Proxyのは、JDKクラス使用
剤。
ターゲットオブジェクトは、任意のインターフェイスのサブクラスを実装していない場合、スプリングCGLIBライブラリーは、対象オブジェクトを使用して生成します。

3-程序中应优先对接口创建代理，便于程序解耦维护

4-标记为final的方法，不能被代理，因为无法进行覆盖

JDK动态代理，是针对接口生成子类，接口中方法不能使用final修饰
CGLib 是针对目标类生产子类，因此类或方法不能使final的

5-Spring只支持方法连接点，不提供属性连接

6-Spring AOP增强类型

1-前置通知

在目标方法执行前实施增强

2-后置通知

在目标方法执行后实施增强

3-环绕通知

在目标方法执行前后实施增强

4-异常抛出通知

在方法抛出异常后实施增强

7- Spring AOP切面类型

1.Advisor : 代表一般切面，Advice本身就是一个切面，对目标类所有方法进
行拦截。

public interface StudentDao {
    public void find();

    public void save();

    public void update();

    public void delete();
}

* * *
public class StudentDaoImpl implements  StudentDao {
    public void find() {
        System.out.println("学生查询...");
    }

    public void save() {
        System.out.println("学生保存...");
    }

    public void update() {
        System.out.println("学生修改...");
    }

    public void delete() {
        System.out.println("学生删除...");
    }
}

* * *
public class MyBeforeAdvice implements MethodBeforeAdvice {
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("前置增强======================");
    }
}

* * *
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo3 {

    // @Resource(name="studentDao")
    @Resource(name="studentDaoProxy")
    private StudentDao studentDao;

    @Test
    public void demo1(){
        studentDao.find();
        studentDao.save();
        studentDao.update();
        studentDao.delete();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置目标类=======================-->
    <bean id="studentDao" class="com.imooc.aop.demo3.StudentDaoImpl"/>

    <!--前置通知类型=====================-->
    <bean id="myBeforeAdvice" class="com.imooc.aop.demo3.MyBeforeAdvice"/>

    <!--Spring的AOP 产生代理对象-->
    <bean id="studentDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!--配置目标类-->
        <property name="target" ref="studentDao"/>
        <!--实现的接口-->
        <property name="proxyInterfaces" value="com.imooc.aop.demo3.StudentDao"/>
        <!--采用拦截的名称-->
        <property name="interceptorNames" value="myBeforeAdvice"/>
        <property name="optimize" value="true"></property>
    </bean>
</beans>

2.PointcutAdvisor : 代表具有切点的切面，可以指定拦截目标类哪些方法

3.IntroductionAdvisor : 代表引介切面，针对引介通知而使用切面

AOP