自定义注解与设计模式

一：什么是注解？
开发中，为了简化代码推荐使用大量注解。简化代码。提高开发效率。
springmvc，springboot,
自定义注解？
注解分类？
内置注解jdk自带注解
自定义注解--框架
任何一个继承Object类，Object类中有哪些方法？
toString(),wait(),notify(),finalize(),clone()..
@Deprecated:过时标识注解
@SuppressWarning:清除警告

二：自定义注解--实现ORM框架映射。
@Retention:表示需要什么级别保存该注释信息，用于描述注解的
生命周期（被描述的注解在什么范围内有效）
三：使用注解实现OR框架映射
思路：使用Java反射机制获取每个属性上的注解value值，
再拼接成数据库sql语句。

四：设计模式

主要作用：重复利用，代码易于扩展，提高阅读，减少代码。
设计模式23种：
分为三大类：
1.创建型 ##工厂，单例
2.结构型 ##代理，适配器
3.行为型 ##策略模式
设计模式六大原则：
1.开闭原则 ##扩展性，易于扩展
2.里氏代换原则 ##面向对象
3.依赖倒转原则 ##面向接口编程
4.接口隔离原则 ##接口分离
5.迪米特法则 ##定义类尽量少与其它类相互作用
6.合成复用原则 ##代码复用

面向对象和面向接口编程。

五：什么是单例--面试必问？
保证jvm中只能有一个实例。
懒汉式，饿汉式
区别？
懒汉式--线程不安全，需要的时候才会创建。
饿汉式--天生线程安全，jvm加载的时候初始化。

六：工厂设计模式？
创建者和调用者分离。

七：代理模式:

什么是代理设计模式？
通过代理控制对象的访问，可以详细访问某个对象的方法，在这个
方法调用处理，或者调用后处理（AOP微实现）
面向切面编程，面向Aop编程。

代理应用场景：
安全代理可以屏蔽真实角色
远程代理可以远程调用代理类RMI
延迟加载先加载轻量级代理类，真正需要再加载真实类。
Aop 日志打印，事务，权限控制。

代理分类：
静态代理：需要生成代理类
动态代理：不需要生成代理类
jdk动态代理，CGLIB动态代理。

八：静态代理：静态定义代理类

九：动态代理：
不需要生成代理类。
实现InvocationHandler就可以

十：CGLIB与JDK动态代理区别：

Java动态代理是利用反射机制生成一个实现代理接口的匿名类。
在调用具体方法前调用InvocationHandler来处理。
而CGLIB动态代理是利用asm开源包，对代理对象类的class文件
加载进来，通过修改其字节码生成子类来处理。
1.如果目标对象实现了接口，默认情况下采用JDK的动态代理实现AOP；
2.如果目标对象实现了接口，可以强制使用CGLIB实现AOP
3.如果目标对象没有实现接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换。

自定义表映射注解

package com.xuyuedu.auto;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Field;

//注解是对应表的关联
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
	String Value();
}
//属性对应的注解
@Retention(RetentionPolicy.RUNTIME)
@interface Property{
	String name();
	int leng() default 0;
}

@Table(Value = "t_student")
class Student{
	@Property(name="student_id",leng=10)
	private String  studentId;
	@Property(name="student_name")
	private String studentName;
	@Property(name="student_age")
	private String studentAge;
}
public class Test003 {

	public static void main(String[] args) throws Exception {
		Class<?> forName = Class.forName("com.xuyuedu.auto.Student");
	
		//获取所有当前属性
		//[private java.lang.String com.xuyuedu.auto.Student.studentId, 
		//private java.lang.String com.xuyuedu.auto.Student.studentName,
		//private java.lang.String com.xuyuedu.auto.Student.studentAge]
		Field[] declaredFields = forName.getDeclaredFields();
		StringBuffer sf = new StringBuffer();
		sf.append(" select ");
		//遍历当前属性
		for (int i = 0; i < declaredFields.length; i++) {
			//1.private java.lang.String com.xuyuedu.auto.Student.studentId
			//2.private java.lang.String com.xuyuedu.auto.Student.studentName,
			//3.private java.lang.String com.xuyuedu.auto.Student.studentAge
			Field field = declaredFields[i];
			//获取属性上的注解
			//[email protected](leng=10, name=student_id)
			//[email protected](name="student_name")
			//[email protected](name="student_age")
			Property property = field.getDeclaredAnnotation(Property.class);
			//1.student_id
			//2.student_name
			//3.student_age
			sf.append(property.name());
			if(i<declaredFields.length-1) {
				sf.append(",");
			}
		}
		//获取类上注解参数
		//@com.xuyuedu.auto.Table(Value=t_student)
		Table declaredAnnotation = forName.getDeclaredAnnotation(Table.class);
		//t_student
		sf.append(" from "+declaredAnnotation.Value());
		System.out.println(sf.toString());
	}
}

测试结果：

 select student_id,student_name,student_age from t_student

饿汉式：

package com.xuyuedu.auto;

//保证在jvm中只能有一个实例
class Singleton{
	//懒汉式
	//需要的时候才会去创建对象
	static private volatile Singleton singleton;
	private Singleton() {
		
	}
	//保证返回一个实例,加锁保证只能允许有一个线程访问getSingleton，效率低
	static public Singleton getSingleton() {
		
		if(singleton==null) {//第一层加锁
			synchronized (Singleton.class) {
				if(singleton==null) {//第二层加锁，双重检验
					singleton=new Singleton();
				}
				
			}
		}
		//当对象不为空的时候，不用考虑线程安全问题
		return singleton;
	}

}
public class Test004 {

	public static void main(String[] args) {
		Singleton s1 = Singleton.getSingleton();
		Singleton s2 = Singleton.getSingleton();
		System.out.println(s1==s2);
	}
}

测试结果：

true

设计模式：工厂方法

package com.xuyuedu.auto;

interface Car{
	void run();
}
class AoDi implements Car{

	@Override
	public void run() {
		System.out.println("我是奥迪汽车--我是奥迪A6");
	}
	
}
class BenChi implements Car{

	@Override
	public void run() {
		System.out.println("我是奔驰汽车--我是奔驰E级");
	}
	
}
//奥迪工厂
class AoDiFactory{
	static public Car createcar() {
		return new AoDi();
		
	}
}
//奔驰工厂
class BenChiFactory{
	static public Car createcar() {
		return new BenChi();
		
	}
}
//工厂
class CarFactory{
	static public Car createCar(String name) {
	Car car=null;
	switch (name) {
	case "奥迪":
		car=new AoDi();
		break;
	case "奔驰":
		car=new BenChi();
		break;
	default:
		break;
	}
	return car;
	}
}
public class Test005 {

	public static void main(String[] args) {
//		Car createCar = CarFactory.createCar("奔驰");
//		createCar.run();
		Car createcar = AoDiFactory.createcar();
		createcar.run();
	}
}

测试结果：

我是奥迪汽车--我是奥迪A6

代理设计模式：

package com.xuyuedu.auto;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

interface Hose{
	void buyHouse();
}
class xuyu implements Hose{

	@Override
	public void buyHouse() {
		System.out.println("我是须臾，我要买房了。。");
	}
	
}
class jdkProxy implements InvocationHandler{

	private Object target;
	jdkProxy(Object target) {
		this.target=target;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] obj) throws Throwable {
		System.out.println("我是中介，开始买房了");
		Object invoke = method.invoke(target, obj);
		System.out.println("我是中介，你买房结束了");
		return invoke;
	}
	
}
//静态代理
class Proxy implements Hose{

	//代理对象
	private xuyu xy;
	public Proxy(xuyu xy) {
		this.xy=xy;
	}
	@Override
	public void buyHouse() {
		System.out.println("我是中介，你买房的任务交给我了。。");
		xy.buyHouse();
		System.out.println("我是中介，你买房完了。。");
	}
	
}
public class Tests {

	public static void main(String[] args) {
//		Hose hose = new Proxy(new xuyu());
//		hose.buyHouse();
		xuyu xy = new xuyu();
		jdkProxy jdkProxy = new jdkProxy(xy);
		Hose hose=(Hose) java.lang.reflect.Proxy.newProxyInstance
				(xy.getClass().getClassLoader(), xy.getClass().getInterfaces(), jdkProxy);
		hose.buyHouse();
	}
}

测试结果：

我是中介，开始买房了
我是须臾，我要买房了。。
我是中介，你买房结束了

CGLIB动态代理：

package com.xuyuedu.eh;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

interface Hose{
	void buyHouse();
}
class xuyu implements Hose{

	@Override
	public void buyHouse() {
		System.out.println("我是须臾，我要买房了。。");
	}
	
}
/**
 * CGLIB动态代理
 * @author DELL
 *
 */
 class CGlib implements MethodInterceptor{

	@Override
	public Object intercept(Object oj, Method method, Object[] arrays, MethodProxy methodProxy) throws Throwable {
		
		System.out.println("我是中介，开始买房了");
		//methodProxy：net.sf.cglib.proxy.MethodProxy@3f2a3a5
		Object invokeSuper = methodProxy.invokeSuper(oj, arrays);
		System.out.println("我是中介，你买房结束了");
		return invokeSuper;
	}
	
}
public class Tests {

	public static void main(String[] args) {

		xuyu  xy=new xuyu();
		//com.xuyuedu.eh.CGlib@7a7b0070
		CGlib cglib = new CGlib();
		//net.sf.cglib.proxy.Enhancer@11531931
		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(xuyu.class);
		enhancer.setCallback(cglib);
		Hose hose=(Hose) enhancer.create();
		hose.buyHouse();
	}
}

测试结果：

我是中介，开始买房了
我是须臾，我要买房了。。
我是中介，你买房结束了

自定义注解与设计模式

猜你喜欢