基础加强(@注解)

一、类加载器

1．什么是类加载器，作用是什么？

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

除了修改源码外利用反射对字节码进行修改

2．类加载器的种类

类加载器有三种，不同类加载器加载不同的

怎么获得类加载器？(重点)

ClassLoader 字节码对象.getClassLoader();

package com.itheima.classloader;

public class Demo {

    public static void main(String[] args) {
        
        //获得Demo字节码文件的类加载器
        Class clazz = Demo.class;//获得Demo的字节码对象
        ClassLoader classLoader = clazz.getClassLoader();//获得类加载器
        //getResource的参数路径相对classes（src）
        //获得classes(src)下的任何的资源
        String path = classLoader.getResource("com/itheima/classloader/jdbc.properties").getPath();
        //classLoader.getResourceAsStream("");
        System.out.println(path);
        
    }
    
}

View Code

一、注解 @xxx

1．什么是注解，注解作用

注解就是符合一定格式的语法 @xxxx

注解作用：

注释：在阅读程序时清楚----给程序员看的

注解：给jvm看的，给机器看的

注解在目前而言最主流的应用：代替配置文件

关于配置文件与注解开发的优缺点：

注解优点：开发效率高成本低

注解缺点：耦合性大并且不利于后期维护

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


@WebServlet("/DemoServlet")
public class DemoServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        response.getWriter().append("Served at: ").append(request.getContextPath());
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
        doGet(request, response);
    }

}

注释代替xml配置

没有xml配置,访问/DemoServlet

package com.itheima.annotation;

import java.util.ArrayList;
import java.util.List;
//压制警告
public class AnnoDemo {


    public static void main(String[] args) {


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

        show();

    }


    //定义方法过时
    @Deprecated
    public static void show(){

    }

    public static void show(String xx){

    }


    //帮助开发人间检查是否覆盖父类的方法发正确
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return super.toString();
    }

}

几种注释

2．jdk5提供的注解

@Override：告知编译器此方法是覆盖父类的

@Deprecated：标注过时

@SuppressWarnings：压制警告

发现的问题：

不同的注解只能在不同的位置使用(方法上、字段上、类上)

3．自定义注解（了解）

1）怎样去编写一个自定义的注解

2）怎样去使用注解

3）怎样去解析注解-----使用反射知识

(1)编写一个注解

关键字：@interface

注解的属性：

语法：属性名称(); 注解属性

注意：如果属性的名字是value，并且注解的属性值有一个那么在使用注解时可以省略value

package com.itheima.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno {

    //注解的属性
    String name();
    
    int age() default 28;
    
    //String value();
    
    //String[] value();
    
    
}

View Code

注解属性类型只能是以下几种

1.基本类型

2.String

3.枚举类型

4.注解类型

5.Class类型

6.以上类型的一维数组类型

(2)使用注解

在类/方法/字段上面是@XXX

package com.itheima.annotation;
@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...");
    }
    
}

使用注解MyAnno

package com.itheima.annotation;

import java.lang.reflect.Method;

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
        
        //根据业务需求写逻辑代码
        
    }
    
}

获得注解参数

package com.itheima.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno {

    //注解的属性
    String name();
    
    int age() default 28;
    
    //String value();
    
    //String[] value();
    
    
}

注解(带元注解)

没有元注解不能显示参数

(3)解析使用了注解的类

介入一个概念：元注解：代表修饰注解的注解，作用：限制定义的注解的特性

@Retention

SOURCE: 注解在源码级别可见

CLASS：注解在字节码文件级别可见

RUNTIME：注解在整个运行阶段都可见

@Target

代表注解修饰的范围：类上使用，方法上使用，字段上使用

FIELD:字段上可用此注解

METHOD:方法上可以用此注解

TYPE:类/接口上可以使用此注解

注意：要想解析使用了注解的类，那么该注解的Retention必须设置成Runtime

关于注解解析的实质：从注解中解析出属性值

字节码对象存在于获得注解相关的方法

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

getAnnotation(Class<A> annotationClass) ：获得该字节码对象身上的注解对象

模拟单元测试

package com.itheima.case1;

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...");
    }
    
}

模拟测试@Test

右键run as+unin test

package com.itheima.case1;

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);
                }
            }
        }
        
    }
    
}

运行@Mytest

一、动态代理(难理解)

1．什么是代理(中介)

目标对象/被代理对象 ------ 房主：真正的租房的方法

代理对象 ------- 黑中介：有租房子的方法（调用房主的租房的方法）

执行代理对象方法的对象 ---- 租房的人

流程：我们要租房----->中介（租房的方法）------>房主（租房的方法）

抽象：调用对象----->代理对象------>目标对象

2．动态代理

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

动态代理的API：

在jdk的API中存在一个Proxy中存在一个生成动态代理的的方法newProxyInstance

static Object

newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

返回值：Object就是代理对象

参数：loader：代表与目标对象相同的类加载器-------目标对象.getClass().getClassLoader()

interfaces：代表与目标对象实现的所有的接口字节码对象数组

h：具体的代理的操作，InvocationHandler接口

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

搞清楚接口目标对象代理对象的格式实际代入

package com.itheima.proxy;

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;
    }

    
    
}

目标对象

package com.itheima.proxy;

public interface TargetInterface {

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

接口

package com.itheima.proxy;

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);
        
    }
    
}

代理一

package com.itheima.proxy;

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);
        
    }
    
}

代理对象二

案例二:使用动态代理完成全局编码

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);

View Code