"文章目录一、动态代理 1.1、代理模式 1.2、动态代理 1.3、AOP(面向切面编程) 编程思想（Spring 框架中的核心思想之一）二、注解 2.1、JDK 中的三个基本的注解： 2.2、自定义注解的语法（注解的肉体） 2.3、注解的反射（注解的灵魂） 2.4、元注解三、简单介绍 Serv ...."

someone1
AI专业者开发社区 1 号成员
AI开发者社区 • 0 回帖 • 4 浏览 • 5 个月前

day19_java基础加强_动态代理+注解+类加载器

文章目录

回到顶部

一、动态代理

1.1、代理模式

什么是代理模式及其作用？

Proxy Pattern（即：代理模式），23 种常用的面向对象软件的设计模式之一。
代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。
在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

优点：

(1) 职责清晰，真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。
(2) 代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了保护目标对象的作用。
(3) 高扩展性。

结构：

一个是你要访问的真正的对象 (目标类)，另一个是代理对象，真正对象(目标对象) 与代理对象实现同一个接口，先访问代理类再访问真正要访问的对象。
其实装饰(包装)设计模式就是静态代理。

静态代理模式简单案例：
KindWomen.java（接口）

package com.itheima.demo;
public interface KindWomen {
    public void throwEye();
    public void doSomething();
}

PJL.java（目标类 1 实现接口，并具体实现）

package com.itheima.demo;
public class PJL implements KindWomen {
    @Override
    public void throwEye() {
        System.out.println("潘金莲抛媚眼");
    }
    @Override
    public void doSomething() {
        System.out.println("潘金莲 XOXO");
    }
}

YPX.java（目标类 2 实现接口，并具体实现）

package com.itheima.demo;
public class YPX implements KindWomen {
    @Override
    public void throwEye() {
        System.out.println("阎婆惜抛媚眼");
    }
    @Override
    public void doSomething() {
        System.out.println("阎婆惜 XOXO");
    }
}

WP.java（代理类也实现接口，但是空实现）

package com.itheima.demo;
public class WP implements KindWomen {
    private KindWomen kw;
    public WP(KindWomen kw) {
        this.kw = kw;
    }
    @Override
    public void throwEye() {
        kw.throwEye();
    }
    @Override
    public void doSomething() {
        kw.doSomething();
    }
}

XMQ.java（我）

package com.itheima.demo;
public class XMQ {
    public static void main(String[] args) {
        PJL pjl = new PJL();
        YPX ypx = new YPX();
        KindWomen wp1 = new WP(pjl);
        KindWomen wp2 = new WP(ypx);
        wp1.throwEye();
        wp1.doSomething();
        wp2.throwEye();
        wp2.doSomething();
}

1.2、动态代理

动态代理它可以直接给某一个目标对象生成一个代理对象，而不需要代理类存在。
动态代理与代理模式原理是一样的，只是它没有具体的代理类，直接通过反射生成了一个代理对象。
动态代理生成技术:
1、基于 jdk 提供一个Proxy类，可以直接给实现某接口的实现类直接生成代理对象。
2、基于 cglib (spring 框架会学习)
java.lang.reflect.Proxy; 该类可以直接生成一个代理对象。

Proxy类的方法：
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 返回一个指定接口的代理类实例。
仅能代理实现至少一个接口的类 (即目标对象需要至少有一个接口)。
ClassLoader：类加载器。固定写法，和被代理类使用相同的类加载器即可。
Class[]：代理类要实现的接口。固定写法，和被代理类使用相同的接口即可。
InvocationHandler：策略（方案）设计模式的应用。如何去具体实现代理，由我们自己决定。

InvocationHandler接口中的invoke方法：调用代理类的任何方法，此方法都会执行。
Object invoke(Object proxy, Method method, Object[] args)
Object proxy：代理对象本身的引用。一般用不着。
Method method：当前调用的方法。
Object[] args：当前方法用到的参数。

动态代理的应用：

在动态代理技术里，由于不管用户调用代理对象的什么方法，都是调用开发人员编写的处理器的 invoke 方法（这相当于invoke方法拦截到了被代理对象的方法调用）。
并且，开发人员通过 invoke 方法的参数，还可以在拦截的同时，知道用户调用的是什么方法，因此利用这两个特性，就可以实现一些特殊需求，例如：拦截用户的访问请求，以检查用户是否有访问权限、动态地为目的对象添加额外的功能。

动态代理模式简单案例：
KindWomen.java（接口）

package com.itheima.demo;
public interface KindWomen {
    public void throwEye(double money);
    public void doSomething(double money);
}

PJL.java（目标类 1 实现接口，并具体实现）

package com.itheima.demo;
public class PJL implements KindWomen {
    @Override
    public void throwEye(double money) {
        System.out.println("潘金莲拿了" + money + "元钱，抛媚眼");
    }
    @Override
    public void doSomething(double money) {
        System.out.println("潘金莲拿了" + money + "元钱，XOXO");
    }
}

XMQ.java（我）

package com.itheima.demo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class XMQ {
    public static void main(String[] args) {
        final KindWomen kw = new PJL(); // 真实对象（目标对象）
        // final YPX ypx = new YPX();
        // PJL pjl = new PJL();
        // YPX ypx = new YPX();
        // KindWomen wp1 = new WP(pjl);
        // KindWomen wp2 = new WP(ypx);
        // wp1.throwEye();
        // wp1.doSomething();
        // wp2.throwEye();
        // wp2.doSomething();
        // public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 
        // 返回一个指定接口的代理类实例。仅能代理实现至少一个接口的类 (即目标对象至少有一个接口)。
        KindWomen proxy = (KindWomen) Proxy.newProxyInstance(kw.getClass().getClassLoader(), kw.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("代理帮你做事情之前，可以做别的事情");
                Object o = method.invoke(kw, new Object[] { (Double) args[0] / 2 }); // 这是真实对象执行的方法 (做的事情)
                System.out.println("代理帮你完做事情之后，仍可以做别的事情");
                return o;
            }
        });
        proxy.throwEye(5);
        proxy.doSomething(10);
    }
}

静态 / 动态代理图解：

1.3、AOP(面向切面编程) 编程思想（Spring 框架中的核心思想之一）

Spring 框架中的核心思想包括：
Dependency Injection(依赖注入)
Inverse of Control(控制反转)
Aspect Oriented Programming(面向切面编程)
AOP 编程思想解决的问题：
1、问题：业务的方法日后会很多，这样会有很多重复的代码。
2、问题：业务已经存在很多的方法，并没有考虑到事务的问题，现在要求加上。那么业务的重心就变了。

动态代理实现 AOP 示例代码：（转账功能）
完成业务的代码：

package com.itheima.service.impl;
import com.itheima.dao.AccountDao;
import com.itheima.dao.impl.AccountDaoImpl;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
public class AccountServiceImpl implements AccountService {
    @Override // 运用 AOP 思想，转账功能就是转账功能，不要加其他的东西，比如事务控制、日志、权限控制等，这样代码健壮性好，优美。
    public void transfer(String fromname, String toname, double money) throws Exception {
        // ad.updateAccount(fromname, toname, money);
        AccountDao ad = new AccountDaoImpl();
        // 分别得到转出和转入账户对象
        Account fromAccount = ad.findAccountByName(fromname);
        Account toAccount = ad.findAccountByName(toname);
        // 修改账户各自的金额
        fromAccount.setMoney(fromAccount.getMoney() - money);
        toAccount.setMoney(toAccount.getMoney() + money);
        // 完成转账操作
        ad.updateAccout(fromAccount);
        // int i = 10 / 0;
        ad.updateAccout(toAccount);
    }
}
/*
package com.itheima.service.impl;
import java.sql.Connection;
import java.sql.SQLException;
import com.itheima.dao.AccountDao;
import com.itheima.dao.impl.AccountDaoImpl;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import com.itheima.util.C3P0Util;
import com.itheima.util.ManagerThreadLocal;
public class AccountServiceImpl implements AccountService {
    @Override
    public void transfer(String fromname, String toname, double money) {
        // ad.updateAccount(fromname, toname, money);
        AccountDao ad = new AccountDaoImpl();
        try {
            ManagerThreadLocal.startTransacation(); // 开启事务
            // 分别得到转出和转入账户对象
            Account fromAccount = ad.findAccountByName(fromname);
            Account toAccount = ad.findAccountByName(toname);
            // 修改账户各自的金额
            fromAccount.setMoney(fromAccount.getMoney() - money);
            toAccount.setMoney(toAccount.getMoney() + money);
            // 完成转账操作
            ad.updateAccout(fromAccount);
            // int i = 10 / 0;
            ad.updateAccout(toAccount);
            ManagerThreadLocal.commit(); // 提交事务
        } catch (Exception e) {
            try {
                ManagerThreadLocal.rollback(); // 回滚事务
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        } finally {
            try {
                ManagerThreadLocal.close(); // 关闭
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
    }
}
*/

产生代理对象的工厂代码：

package com.itheima.util;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.itheima.service.AccountService;
import com.itheima.service.impl.AccountServiceImpl;
public class ObjectFactory {
    // 该方法返回一个代理对象
    public static AccountService getAccountService() {
        final AccountService as = new AccountServiceImpl(); // 真实对象（目标对象）
        AccountService proxy = (AccountService) Proxy.newProxyInstance(as.getClass().getClassLoader(),
                as.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object invoke = null;
                        try {
                            ManagerThreadLocal.startTransacation(); // 开启事务
                            // 执行的是真实对象的转账方法
                            invoke = method.invoke(as, args);
                            ManagerThreadLocal.commit(); // 提交事务
                        } catch (Exception e) {
                            try {
                                ManagerThreadLocal.rollback(); // 回滚事务
                            } catch (Exception e1) {
                                e1.printStackTrace();
                            }
                        } finally {
                            try {
                                ManagerThreadLocal.close(); // 关闭
                            } catch (Exception e) {
                                e.printStackTrace();
                            } 
                        }
                        return invoke;
                    }
                });
        return proxy;
    }
}

测试类代码：

package com.itheima.test;
import com.itheima.service.AccountService;
import com.itheima.util.ObjectFactory;
public class TestTransfer {
    /**
      @param args
      @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // AccountService as = new AccountServiceImpl();
        // as.transfer("aaa", "bbb", 100);
        AccountService as = ObjectFactory.getAccountService();
        as.transfer("aaa", "bbb", 100);
    }
}
/*
package com.itheima.test;
import com.itheima.service.AccountService;
import com.itheima.service.impl.AccountServiceImpl;
import com.itheima.util.ObjectFactory;
public class TestTransfer {
    /**
      @param args
      @throws Exception
     */
    public static void main(String[] args) throws Exception {
        AccountService as = new AccountServiceImpl();
        as.transfer("aaa", "bbb", 100);
    }
}
*/

回到顶部

二、注解

注解不是注释，注释是程序员写的，给程序员看的。注解给程序看，用于描述程序如何运行及在什么阶段来运行。
现在在实际开发中，注解最大的功能是用于替换配置文件。
注解是jdk1.5的新特性。
可以通过反射来让注解具有功能。
注解格式： @Xxxx

2.1、JDK 中的三个基本的注解：

a. @Override 检查子类确实是覆盖了父类的方法。
b. @Deprecated 说明已经过时了。
c. @SuppressWarnings({"unused", "deprecation", "rawtypes"})
抑制程序中的警告。unused(变量未使用)、deprecation(过时)和rawtypes(泛型)表示警告的类型。{} 数组。
d. @SuppressWarnings("all") all 抑制所有警告。

示例代码如下：

package com.itheima.demo1;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class Demo1 {
    // @SuppressWarnings({ "unused", "deprecation", "rawtypes" }) 
    @SuppressWarnings("all")
    public void ff() {
        int i = 0;
        System.out.println("abc");
        List list = new ArrayList();
        System.out.println(new Date().toLocaleString());
    }
    public void HaHa() {
    }
}
class Demo2 extends Demo1 {
    @Override
    public void ff() {
    }
    @Deprecated
    public void HaHaHa() {
        System.out.println(new Date().toLocaleString());
    }
}

2.2、自定义注解的语法（注解的`肉体`）

研究一下注解的本质：
声明一个注解 (或者创建一个注解类)： @interface 注解名｛...｝

    public @interface MyAnnotation {}

通过反编译可知，注解它的本质就是一个接口，这个接口需要继承 Annotation接口。但是不能按照下述的代码格式写，需要按照上述代码格式写。

    public interface MyAnnotation extends java.lang.annotation.Annotation {...}

分析注解类中的成员：
注解本质上就是接口，我们知道接口中可以有属性和方法。
属性：public static final int age;
方法：public abstract void show();
但是在注解中也可以有属性，也可以有方法。但是，注解中一般不使用属性。
在注解的开发中，我们只写方法。
我们管注解中的方法，叫做注解的属性。
在注解中我们管方法的返回值叫做注解的类型。
注解定义属性的格式：例如：int age();
关于注解的属性类型可以有哪些?
1、基本类型
2、String
3、枚举类型
4、注解类型
5、Class 类型
6、以上类型的一维数组类型

注解：就是在你的程序代码中的某个位置加了一个标记而已。
示例代码如下图所示：

2.3、注解的反射（注解的灵魂）

模拟 Junit 的 @Test 方法

a、反射注解类
java.lang.reflect.AnnotatedElement;
< T extends Annotation > T getAnnotation(Class< T > annotationType) 得到指定类型的注解引用。没有，返回 null。
Annotation[] getAnnotations() 得到所有的注解，包含从父类继承下来的。
Annotation[] getDeclaredAnnotations() 得到自己身上的注解。
boolean isAnnotationPresent(Class< ? extends Annotation > annotationType) 判断指定的注解有没有。

Class、Method、Field、Constructor 等实现了 AnnotatedElement接口。
例如：
Class.isAnnotationPresent(MyTest.class); 判断类上面有没有 @MyTest 注解。
Method.isAnnotationPresent(MyTest.class); 判断方法上面有没有 @MyTest 注解。

b、反射注解中的属性
如下图元注解图片中所示：

2.4、元注解

a、自定义注解的存活范围（生命周期）：默认是 CLASS。

什么是元注解？答：只能用在注解类上的注解叫做元注解。（即：用于修饰注解的注解）

@Retention 作用：改变自定义注解的存活范围。
RetentionPolicy
SOURCE
CLASS
RUNTIME
例如：@Retention(RetentionPolicy.RUNTIME)
@Target 作用：指定该注解能用在什么地方。
ElementType
TYPE
METHOD
FIELD
ANNOTATION_TYPE
例如：@Target({ ElementType.METHOD, ElementType.TYPE })
@Documented 作用：使用了 @MyTest 的注解的类，如果 @MyTest 注解类上面有 @Documented 注解，那么使用了 @MyTest 的注解的类的 API 文档中会出现 @MyTest 的身影。
@Inherited 作用：说明使用了该注解的类的子类可以继续使用该注解。

示例代码如下图所示：

回到顶部

三、简单介绍 Servlet3.0 中的几个注解

增加对注解的支持。
Servlet3.0
要求：Tomcat7+ 和 JDK6.0+

Servlet3.0：web.xml 已经不是必须的了。替代它的就是注解。

截图如下：

回到顶部

四、类加载器

1、作用：类加载器负责将 .class 文件 ( 可能在磁盘上, 也可能在网络上) 加载到内存中, 并为之生成对应的 java.lang.Class。
2、JVM 中的类加载器：（当 JVM 启动时，会形成由三个类加载器组成的初始类加载器层次结构：）
BootStrap：是老大。类加载器的祖先。打印它会得到 null。
负责加载 JRE/lib/rt.jar(JDK 中绝大部分的类)
ExtClassLoader：
负责加载 JRE/lib/ext/*.jar
AppClassLoader：
负责加载在 classpath环境变量中的所有类
类加载器之间的父子关系图和管辖范围图;

3、父类委托机制（全盘负责委托机制）
例如：用 eclipse 的打包工具将 TestClassLoader 输出成 jre/lib/ext 目录下的 itcast.jar 包，再在 eclipse 中运行这个类，运行结果显示为 ExtClassLoadr。此时的环境状态是 classpath 目录有 TestClassLoader.class，ext/itcast.jar 包中也有 TestClassLoader.class，我们知道，使用一个类，应该只出现一个字节码文件，现在却出现两个了，肿么办？这时候我们就需要了解类加载的具体过程和原理了。如下所示：

bootstrap classloader：引导（也称为原始）类加载器，它负责加载 Java 的核心类。这个加载器是非常特殊的，它实际上不是 java.lang.ClassLoader 的子类，而是由 JVM 自身实现的 (底层是 c 代码)。因为 JVM 在启动的时候就自动加载它们, 所以不需要在系统属性 CLASSPATH 中指定这些类库。
extension classloader：扩展类加载器，它负责加载 JRE 的扩展目录（JAVA_HOME/jre/lib/ext 或者由 java.ext.dirs 系统属性指定的）中的 JAR 包。这为引入除 Java 核心类以外的新功能提供了一个标准机制。因为默认的扩展目录对所有从同一个 JRE 中启动的 JVM 都是通用的，所以放入这个目录的 JAR 类包对所有的 JVM 和 system classloader 都是可见的。
system classloader：系统（也称为应用）类加载器，它负责在 JVM 被启动时，加载来自在命令 java 中的 -classpath 或者 java.class.path 系统属性或者 CLASSPATH 操作系统属性所指定的 JAR 类包和类路径。可以通过静态方法ClassLoader.getSystemClassLoader();找到该类加载器。如果没有特别指定，则用户自定义的任何类加载器都将该类加载器作为它的父加载器。

classloader 加载类用的是全盘负责委托机制。
全盘负责：即是当一个 classloader 加载一个 Class 的时候，这个 Class 所依赖的和引用的其它 Class通常也由这个 classloader 负责载入。
委托机制：先让 parent（父）类加载器寻找，只有在 parent 找不到的时候才从自己的类路径中去寻找。
类加载还采用了cache机制：如果 cache 中保存了这个 Class 就直接返回它，如果没有才从文件中读取和转换成 Class，并存入 cache，这就是为什么修改了Class但是必须重新启动JVM才能生效，并且类只加载一次的原因。

示例代码：

package com.itheima;

import javax.xml.crypto.dsig.keyinfo.KeyName;

public class TestClassLoader {
    public static void main(String[] args) {
        // BootStrap：是老大。类加载器的祖先。 打印它会得到 null。负责加载 JRE/lib/rt.jar(JDK 中绝大部分的类) 
        ClassLoader cl = KeyName.class.getClassLoader();
        System.out.println(cl); // null
        // System.out.println(cl.getClass().getName()); // java.lang.NullPointerException

        // ExtClassLoader： 负责加载 JRE/lib/ext/*.jar 
        // 没有找着可以测试的类，因为该目录下需要导入源码包，就没有测试啦！但是效果同 AppClassLoader。

        // AppClassLoader： 负责加载在 classpath 环境变量中的所有类 
        ClassLoader cl1 = Student.class.getClassLoader(); 
        System.out.println(cl1); // sun.misc.Launcher$AppClassLoader@73d16e93
        System.out.println(cl1.getClass().getName()); // sun.misc.Launcher$AppClassLoader
    }
}

示例图解 01：

示例图解 02：

day19_java基础加强_动态代理+注解+类加载器

一、动态代理

1.1、代理模式

1.2、动态代理

1.3、AOP(面向切面编程) 编程思想（Spring 框架中的核心思想之一）

二、注解

2.1、JDK 中的三个基本的注解：

2.2、自定义注解的语法（注解的`肉体`）

2.3、注解的反射（注解的灵魂）

2.4、元注解

三、简单介绍 Servlet3.0 中的几个注解

四、类加载器

相关帖子

随便看看

day19_java基础加强_动态代理+注解+类加载器