java基础第十八篇之单元测试、注解和动态代理

		int sum = a + b;
		return sum;
}

@Test
public void testSum(){
	int result = sum(10, 10);
	//断言，如果条件成立，则程序正常，如果条件不成立，则程序直接结束
	//参1：期望的值 参2：实际得到的值
	assertEquals(20, result);

	xxxxxxxxxxxxxxxxxx
}

注解的作用：
	1.	编译检查：通过代码里标识注解，让编译器能够实现基本的编译检查
	2.	编写文档：通过代码里标识注解，辅助生成帮助文档对应的内容 (@Document)

	ArrayList list = new ArrayList();
	
	list.add("hello");
	
	String str = null;
	
	System.out.println(str.length());
}
public static void method(){
	int a = 123;
}

public int add(int a , int b){
	return a + b;
}

@Test
public void testAdd(){
	int result = add(10, 20);
	//断言
	//参1：表示期望得到的值
	//参2：表示实际得到的值
	//如果两个值一致，程序正常结束，如果不一致程序直接终止
	assertEquals(31, result);
}

自定义注解

 public @interface MyAnnotation {

}

//使用注解
@MyAnnotation
@MyAnnotation1
class Demo{
	public void func(){
		
	}
}
//------------------------------
@MyAnnotation1
@MyAnnotation2
public void func(){
		
}
3.2 给注解添加属性
	2.	返回值类型：基本类型、字符串String、Class、注解、枚举，以及以上类型的一维数组
public @interface MyAnnotation {
	//属性格式：修饰符 返回值类型 属性名()  [default 默认值]
	//1修饰符：默认值 public abstract ，且只能是public abstract。
	public abstract String myString();
	public abstract int myInt() default 123;
}

 
 //-----------------例子-------------------------------
	enum MyEnum{
		Red,Blue
		//public static final MyEnum Red = new MyEnum();
		//public static final MyEnum Blue = new MyEnum();
	}
	public @interface MyAnnotation { //反编译之后，其实是接口
		//给注解添加属性
		public abstract int myInt() default 123; //类似于该方法的返回值
		public abstract String myString();
		public abstract Class myClass();
		public abstract MyAnnotation3 myAnno();
		public abstract MyEnum myEnum();
		
		public abstract int[] myIntArray();
		
		
	}

2.4	自定义注解：使用
	@注解类名( 属性名= 值 , 属性名 = 值 , .....)
	

	//-------------例子------------------------------
	public @interface MyAnnotation4 {
		public abstract String value();
	}

	//如果一个注解只有一个属性，并且名字为value,  则可以不用加属性名
	@MyAnnotation4("hello")
	class Demo2{
		
	}

//当使用一个有属性的注解时，必须指定属性的值

	@interface MyAnnotation{
	}
	Class对象                       //MyAnnotation.class
	    Method :  判断方法上是否有这个注解,参数为注解的Class对象
		Class  :  判断类上是否有这个注解,参数为注解的Class对象
		boolean isAnnotationPresent(Class annotationClass) 当前对象(方法，类)是否有注解
   
	 Class :获取类上的注解,  参数表示要获取的注解的Class对象
     Method:获取方法上的注解, 参数表示要获取的注解的Class对象 										//MyAnnotation.class
       public <T extends Annotation> T getAnnotation(Class<T> annotationClass) //获取注解对象

//---------------------------------------------
	@Retention(RetentionPolicy.RUNTIME) //指定注解的声明周期
	@Target({ElementType.TYPE, ElementType.METHOD}) //指定注解的作用目标
	public @interface MyAnnotation2 {

  }

@MyAnnotation(myString="方法上的注解属性值")
public void func1(){
	System.out.println("func1方法");
}


public void func2(){
	System.out.println("func2方法");
}

@Test
public void parseAnnoClass(){
	//1:获取类的CLass对象
	Class<?> clazz = UseAnnotation.class;
	
	//2:判断类上是否有@MyAnnotation注解
	boolean bl = clazz.isAnnotationPresent(MyAnnotation.class);
	if(bl){
		//3:获取注解
		MyAnnotation annotation = clazz.getAnnotation(MyAnnotation.class);
		//4:调用方法 
		String value = annotation.myString();
		System.out.println(value);
	}
}





//在该方法中获取注解的属性值
@Test
public void parseAnno(){
	//1:获取类的Class对象
	Class<?> clazz = UseAnnotation.class;
	
	//2:因为不知道哪个方法有注解，所以需要获取所有的方法
	Method[] methods = clazz.getMethods();
	//3:遍历数组，判断哪个方法有注解 
	for (Method method : methods) {
		//这里的参数要指定获取的是哪一个注解
		boolean bl = method.isAnnotationPresent(MyAnnotation.class);

			String value = annotation.myString();
			System.out.println(value);
		}
	}
}

public static void main(String[] args) throws Exception {
	//1:获取使用注解方法所在类Class对象 
	Class<?> clazz = UseAnnotation.class;
	
	Object obj = clazz.newInstance();
	//2:获取所有的方法
	Method[] methods = clazz.getMethods();
	
	for (Method method : methods) {
		//判断哪个方法有注解
		boolean bl = method.isAnnotationPresent(MyTest.class);
		if(bl){
			//如果 哪个方法加了这个注解，就执行哪个方法
			//加了注解之后，还要获取属性值 
			MyTest annotation = method.getAnnotation(MyTest.class);
			String value = annotation.value();
			//只有属性值是run 才能运行
			if(value.equals("run")){
				method.invoke(obj);
			}
		}
	}
}

//获取一个类的加载器
	TestDemo.class.getClassLoader()

加载原则:
全盘负责制: A类要使用B类，A类必须负责加载B类中所有的类
   TestDemo --->String 类
父亲委托制：子类要使用某个类，先要委托父类先加载，如果父类没有加载成功，则子类才会加载
  盘负责委托机制保证一个class文件只会被加载一次，形成一个Class对象。

class F
{
	Demo demo;
}

class Zi extends Fu
{
	Demo demo2();
}

new ZI();

//2:在不改变一个类源码的情况下，屏蔽类中的某些功能
class Demo
{
	 public void method(){
		//System.out.println("功能1");
		//System.out.println("功能2");
		System.out.println("功能3"); 
	}
}

  }

			}
			
		}
	}
}	

@Override
public void run() {
	// TODO Auto-generated method stub
	for(int i = 0; i < 10000; i++) {
		System.out.println("i=" + i);
	}
}

RunnCode obj;


public MyInn3(RunnCode obj) {
	super();
	this.obj = obj;
}


public MyInn3() {
	super();
	// TODO Auto-generated constructor stub
}


@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	// TODO Auto-generated method stub
	long t1 = System.currentTimeMillis();
	Object result = method.invoke(obj, args);
	long t2 = System.currentTimeMillis();
	System.out.println("消耗了:" + (t2-t2) + "毫秒");
	return result;
}

	rc.run();
	
	rc = (RunnCode)Proxy.newProxyInstance(rc.getClass().getClassLoader(), rc.getClass().getInterfaces(), new MyInn3(rc));
	rc.run();
}

	//创建一个InvocationHandler接口的实现类，并在invoke方法中，指定你要增强的方法

	list.add("hello");
	list.add("world");
	
	list = myProxy(list);

private static List<String> myProxy(List<String> list) {
	@SuppressWarnings("unchecked")
	List<String> proxyList=(List<String>)Proxy.newProxyInstance(list.getClass().getClassLoader(),
			list.getClass().getInterfaces(), new MyInvocationHandler(list));
	return proxyList;
}

public MyInvocationHandler() {
	super();
	// TODO Auto-generated constructor stub
}


public MyInvocationHandler(List<String> obj) {
	super();
	this.obj = obj;
}


@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	//屏蔽add，set，remove方法
	if(method.getName().equals("add")){
		throw new RuntimeException("你不能调用add方法");
	}
	if(method.getName().equals("set")){
		throw new RuntimeException("你不能调用set方法");
	}
	if(method.getName().equals("remove")){
		throw new RuntimeException("你不能调用remove方法");
	}
	//其他方法正常调用
	Object result = method.invoke(obj, args);
	return result;
}

@MyTest("run","first")
public void func1(){
	System.out.println("func1方法");
}

@MyTest("run","third")
public void func2(){
	System.out.println("func2方法");
}

@MyTest("aaa")
public void func3(){
	System.out.println("func3方法");
}
@MyTest("run","second")
public void func4(){
	System.out.println("func4方法");
}


@MyTest("run","four")
public void fun5(){
	System.out.println("func2方法");
}