5自定义注解与设计模式

最新推荐文章于 2021-01-03 11:46:00 发布

流星天道酬勤

最新推荐文章于 2021-01-03 11:46:00 发布

阅读量332

点赞数

本文链接：https://blog.csdn.net/weixin_41673498/article/details/104182972

版权

技术烩菜专栏收录该内容

38 篇文章 0 订阅

订阅专栏

object 有什么方法

toString, notifiy,wait,equals等

内置注解

比如

（1） @SuppressWarnings   再程序前面加上可以在javac编译中去除警告--阶段是SOURCE
（2） @Deprecated   带有标记的包，方法，字段说明其过时----阶段是SOURCE
（3）@Overricle   打上这个标记说明该方法是将父类的方法重写--阶段是SOURCE

自定义注解

自定义注解完成ORM框架映射

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  Propety{
    String name();
    int leng() default 0;
}
@Table("t_stu")
class Student{
    @Propety(name = "student_id")
    private String studentId;
    @Propety(name = "student_name")
    private String studentName;
    @Propety(name = "student_age")
    private String studentAge;
}
public class Test004 {
    public static void main(String[] args) throws Exception {
        Class<?> forName = Class.forName("com.cn.Student");//全部路径
        //获取所有方法
        Field[] declaredFields = forName.getDeclaredFields();
        StringBuffer sf = new StringBuffer();
        sf.append("select ");
        for (int i = 0; i < declaredFields.length; i++) {
            Field field = declaredFields[i];
            //获取属性上的注解
            Propety propety = field.getDeclaredAnnotation(Propety.class);
             sf.append(propety.name());
             if (i<declaredFields.length-1){
                 sf.append(",");
             }
        }
        //获取注解参数
        Table declaredAnnotation = forName.getDeclaredAnnotation(Table.class);
        sf.append(" from "+declaredAnnotation.value());
        System.out.println(sf.toString());
    }
}
结果 select student_id,student_name,student_age from t_stu

常用设计模式

1单例模式

保证JVM只能有一个实例

面试写懒汉式--写双重检验锁

//单例模式保证JVM只能有一个实例
class  Singleton{
    //懒汉式
    private static  Singleton singleton;
    private Singleton(){

    }
    //保证一个实例,synchronized只能有一个访问getSingleton方法
    public static Singleton getSingleton(){
        if (singleton==null){//第一次上锁
            synchronized (Singleton.class){
                if (singleton==null){//第二次上锁 双重检验锁
                    singleton=new Singleton();
                }
            }
        }
    return  singleton;
    }
}

//单例模式保证JVM只能有一个实例
class  Singleton{
    //饿汉式
    private static  Singleton singleton=new Singleton();
    private Singleton(){

    }
    public static   Singleton getSingleton() {
        return singleton;
    }

2工厂设计模式

作用：创建者和调用者分离

，它通过面向对象的手法，将所要创建的具体对象的创建工作延迟到了子类，从而提供了一种扩展的策略，较好的解决了这种紧耦合的关系。

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

    @Override
    public void run() {
        System.out.println("我是奥...迪");
    }
}
class BenCi implements  Car{

    @Override
    public void run() {
        System.out.println("我是奔。。。驰");
    }
}
class BenChiFactory{
    public  static  Car createCar(){
        return  new BenCi();
    }
}
class AODIFactory{
    public  static  Car createCar(){
        return  new AoDi();
    }
}
public class Test006 {
    public static void main(String[] args) {
        Car aodi = AODIFactory.createCar();
        Car benchi= BenChiFactory.createCar();
        aodi.run();
        benchi.run();
    }
}

https://blog.csdn.net/weixin_41673498/article/details/103844106

3代理设计模式

面向切面编程

代理：静态代理，缺点需要代理类

动态代理，需要代理类

代理的分类

静态代理(静态定义代理类)

动态代理(动态生成代理类)

Jdk自带动态代理

Cglib 、javaassist（字节码操作库）

静态代理--需要代理类

//静态代理
interface Hose{
    void mai();
}
public class XiaoMing implements Hose {
    @Override
    public void mai() {
        System.out.println("我是小明,我要买房啦!!!!haha ");
    }
}
class Proxy  implements Hose {//中介 --代理类
    private XiaoMing xiaoMing;
    public Proxy(XiaoMing xiaoMing) {
        this.xiaoMing = xiaoMing;
    }
    public void mai() {
        System.out.println("我是中介 看你买房开始啦!");
        xiaoMing.mai();
        System.out.println("我是中介 看你买房结束啦!");
    }
    public static void main(String[] args) {
        Hose proxy = new Proxy(new XiaoMing());
        proxy.mai();
    }
}

JDK动态代理--不需要代理类

jdk动态代理

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

interface Hose {

     void mai();

}


class XiaoMing implements Hose {

    @Override
    public void mai() {
        System.out.println("我是小明,我要买房啦!!!!haha ");
    }

}

//jdk动态代理
public class JDKProxy implements InvocationHandler {
    private Object tarjet;

    public JDKProxy(Object tarjet) {
        this.tarjet = tarjet;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("我是房产中介.....开始监听你买房啦!");
        Object oj = method.invoke(tarjet, args);
        System.out.println("我是房产中介.....结束监听你买房啦!");
        return oj;
    }
}

class Test222 {
    public static void main(String[] args) {
        XiaoMing xiaoMing = new XiaoMing();
        JDKProxy jdkProxy = new JDKProxy(xiaoMing);
        Hose hose=(Hose) Proxy.newProxyInstance(xiaoMing.getClass().getClassLoader(), xiaoMing.getClass().getInterfaces(), jdkProxy);
        hose.mai();
    }

}

cglib代理

<dependency>
   <groupId>cglib</groupId>
   <artifactId>cglib</artifactId>
   <version>2.2.2</version>
 </dependency>

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

import java.lang.reflect.Method;
interface Hose {
    void mai();
}

class XiaoMing implements Hose {
    @Override
    public void mai() {
        System.out.println("我是小明,我要买房啦!!!!haha ");
    }
}

public class CgLib implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("我是买房中介 ， 开始监听你买房了....");
        Object invokeSuper = methodProxy.invokeSuper(o, objects);
        System.out.println("我是买房中介 ， 开结束你买房了....");
        return invokeSuper;
    }
}
class Test{
    public static void main(String[] args) {
        CgLib cgLib = new CgLib();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(XiaoMing.class);
        enhancer.setCallback(cgLib);
        Hose hose =(Hose) enhancer.create();
        hose.mai();
    }
}

CGLIB与JDK动态代理区别

CGLIB使用字节码加载的，jdk动态代理利用反射机制实现

区别：

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP 

2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP 

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换