类加载器&注解&动态代理

最新推荐文章于 2021-06-28 14:19:53 发布

jiangtea

最新推荐文章于 2021-06-28 14:19:53 发布

阅读量340

点赞数

分类专栏： javaee 文章标签：类加载器注解动态代理

本文链接：https://blog.csdn.net/jiangtea/article/details/78837582

版权

javaee 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

1、类加载器

类加载器就加载字节码文件(.class)。

这里写图片描述

1.2、类加载器的种类

类加载器有三种
BootStrap：引导类加载器，加载都是最基础的文件；
ExtClassLoader：扩展类加载器，加载都是基础的文件；
AppClassLoader：应用类加载器，三方jar包和自己编写java文件。

怎么获得类加载器？
ClassLoader 字节码对象.getClassLoader();

//获得Demo字节码文件的类加载器
Class clazz = Demo.class;//获得Demo的字节码对象
ClassLoader classLoader = clazz.getClassLoader();//获得类加载器
//getResource的参数路径相对classes（src）
//获得classes(src)下的任何的资源
String path = classLoader.getResource("com/classloader/jdbc.properties").getPath();
//classLoader.getResourceAsStream("");

2、注解 @xxx

注解就是符合一定格式的语法 @xxxx
注解作用：
注释：在阅读程序时清楚—-给程序员看的
注解：给jvm看的，给机器看的

注解在目前而言最主流的应用：代替配置文件
关于配置文件与注解开发的优缺点：
注解优点：开发效率高，成本低
注解缺点：耦合性大，并且不利于后期维护

2.1、jdk5提供的注解

@Override：告知编译器此方法是覆盖父类的
@Deprecated：标注过时
@SuppressWarnings：压制警告

@SuppressWarnings({ "unused", "rawtypes" })
List list = new ArrayList();

2.2、自定义注解

编写一个注解
关键字：@interface
注解的属性：
语法：返回值名称();
注意：如果属性的名字是value，并且注解的属性值有一个那么在使用注解时可以省略value

注解属性类型只能是以下几种
1.基本类型
2.String
3.枚举类型
4.注解类型
5.Class类型
6.以上类型的一维数组类型

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno {
    //注解的属性
    String name();
    int age() default 28;
    //String value();
    //String[] value();
}

使用注解
在类/方法/字段上面是@XXX

@MyAnno(name = "zhangsan")
public class MyAnnoTest {
    @SuppressWarnings("all")
    @MyAnno(name = "zhangsan")
    //@MyAnno({ "aaa","bbb","ccc"})
    public void show(String str){
        System.out.println("show running...");
    }
}

解析使用了注解的类

介入一个概念：元注解：代表修饰注解的注解，作用：限制定义的注解的特性
@Retention
SOURCE: 注解在源码级别可见
CLASS：注解在字节码文件级别可见
RUNTIME：注解在整个运行阶段都可见
@Target
代表注解修饰的范围：类上使用，方法上使用，字段上使用
FIELD:字段上可用此注解
METHOD:方法上可以用此注解
TYPE:类/接口上可以使用此注解

public class MyAnnoParser {
    public static void main(String[] args) throws NoSuchMethodException, SecurityException {
        //解析show方法上面的@MyAnno
        //直接的目的是 获得show方法上的@MyAnno中的参数
        //获得show方法的字节码对象
        Class clazz = MyAnnoTest.class;
        Method method = clazz.getMethod("show", String.class);
        //获得show方法上的@MyAnno
        MyAnno annotation = method.getAnnotation(MyAnno.class);
        //获得@MyAnno上的属性值
        System.out.println(annotation.name());//zhangsan
        System.out.println(annotation.age());//28
        //根据业务需求写逻辑代码
    }
}

注意：要想解析使用了注解的类，那么该注解的Retention必须设置成Runtime
关于注解解析的实质：从注解中解析出属性值
字节码对象存在于获得注解相关的方法

isAnnotationPresent(Class<? extends Annotation> annotationClass) ： 判断该字节码对象身上是否使用该注解了
getAnnotation(Class<A> annotationClass) ：获得该字节码对象身上的注解对象

3、自定义单元测试

import org.junit.Test;
public class TestDemo {
    //程序员开发中测试用的
    @Test
    public void test1(){
        System.out.println("test1 running...");
    }
    @MyTest
    public void test2(){
        System.out.println("test2 running...");
    }
    @MyTest
    public void test3(){
        System.out.println("test3 running...");
    }
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest {
    //不需要属性
}

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class MyTestParster {
    public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
        //获得TestDemo
        Class clazz = TestDemo.class;
        //获得所有的方法
        Method[] methods = clazz.getMethods();
        if(methods!=null){
            //获得注解使用了@MyTest的方法
            for(Method method:methods){
                //判断该方法是否使用了@MyTest注解
                boolean annotationPresent = method.isAnnotationPresent(MyTest.class);
                if(annotationPresent){
                    //该方法使用MyTest注解了
                    method.invoke(clazz.newInstance(), null);
                }
            }
        }
    }
}

4、动态代理

什么是代理(中介)
目标对象/被代理对象 —— 房主：真正的租房的方法
代理对象 ——- 黑中介：有租房子的方法（调用房主的租房的方法）
执行代理对象方法的对象 —- 租房的人

流程：我们要租房—–>中介（租房的方法）——>房主（租房的方法）
抽象：调用对象—–>代理对象——>目标对象

public interface TargetInterface {
    public void method1();
    public String method2();
    public int method3(int x);
}

public class Target implements TargetInterface{
    @Override
    public void method1() {
        System.out.println("method1 running...");
    }
    @Override
    public String method2() {
        System.out.println("method2 running...");
        return "method2";
    }
    @Override
    public int method3(int x) {
        return x;
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import org.junit.Test;
public class ProxyTest {
    @Test
    public void test1(){
        //获得动态的代理对象----在运行时 在内存中动态的为Target创建一个虚拟的代理对象
        //objProxy是代理对象 根据参数确定到底是谁的代理对象
        TargetInterface objProxy = (TargetInterface) Proxy.newProxyInstance(
                Target.class.getClassLoader(), //与目标对象相同的类加载器
                new Class[]{TargetInterface.class}, 
                new InvocationHandler() {
                    //invoke 代表的是执行代理对象的方法
                    @Override
                    //method：代表目标对象的方法字节码对象
                    //args:代表目标对象的响应的方法的参数
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("目标方法前的逻辑");
                        //执行目标对象的方法
                        Object invoke = method.invoke(new Target(), args);
                        System.out.println("目标方法后的逻辑");
                        return invoke;
                    }
                }
            );
        objProxy.method1();
        String method2 = objProxy.method2();
        System.out.println(method2);
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyTest2 {
    public static void main(String[] args) {
        final Target target = new Target();
        //动态创建代理对象
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), 
                new InvocationHandler() {
                    @Override
                    //被执行几次？------- 看代理对象调用方法几次
                    //代理对象调用接口相应方法 都是调用invoke
                    /*
                     * proxy:是代理对象
                     * method:代表的是目标方法的字节码对象
                     * args:代表是调用目标方法时参数
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //反射知识点
                        Object invoke = method.invoke(target, args);//目标对象的相应方法
                        //retrun返回的值给代理对象
                        return invoke;
                    }
                }
            );

        proxy.method1();//调用invoke---Method：目标对象的method1方法  args：null  返回值null
        String method2 = proxy.method2();//调用invoke---Method:目标对象的method2方法  args:null  返回值method2
        int method3 = proxy.method3(100);调用invoke-----Method:目标对象的method3方法 args:Object[]{100}  返回值100
        System.out.println(method2);
        System.out.println(method3);
    }
}

动态代理：不用手动编写一个代理对象，不需要一一编写与目标对象相同的方法，这个过程，在运行时的内存中动态生成代理对象。——字节码对象级别的代理对象

动态代理的API：

在jdk的API中存在一个Proxy中存在一个生成动态代理的的方法newProxyInstance
static Object   newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

返回值：Object就是代理对象
参数：loader：代表与目标对象相同的类加载器——-目标对象.getClass().getClassLoader()
interfaces：代表与目标对象实现的所有的接口字节码对象数组
h：具体的代理的操作，InvocationHandler接口

注意：JDK的Proxy方式实现的动态代理目标对象必须有接口没有接口不能实现jdk版动态代理。

5、动态代理完成全局编码

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {
    final HttpServletRequest req = (HttpServletRequest) request;
    //使用动态代理完成全局编码
    HttpServletRequest enhanceRequset = (HttpServletRequest) Proxy.newProxyInstance(
            req.getClass().getClassLoader(), 
            req.getClass().getInterfaces(), 
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    //对getParameter方法进行增强
                    String name = method.getName();//获得目标对象的方法名称
                    if("getParameter".equals(name)){
                        String invoke = (String) method.invoke(req, args);//乱码
                        //转码
                        invoke = new String(invoke.getBytes("iso8859-1"),"UTF-8");
                        return invoke;
                    }
                    return method.invoke(req, args);
                }
            }   
        );
    chain.doFilter(enhanceRequset, response);
}