[1.Spring IOC & AOP](#1.Spring IOC & AOP)

[2.Spring bean](#2.Spring bean)

[(1) 作用域](#(1) 作用域)

[(2) Spring 中的 bean ⽣命周期](#(2) Spring 中的 bean ⽣命周期)

[(3) Spring 框架中⽤到了哪些设计模式](#(3) Spring 框架中⽤到了哪些设计模式)

[1.IO 设计模式](#1.IO 设计模式)

[2.Spring 中的设计模式详解](#2.Spring 中的设计模式详解)

3.实践

一.Spring

1.Spring IOC & AOP

IoC
IoC （ Inverse of Control: 控制反转）是⼀种 设计思想 ，就是 将原本在程序中⼿动创建对象的控制
权，交由 Spring 框架来管理。 IoC 在其他语⾔中也有应⽤，并⾮ Spring 特有。 IoC 容器是 Spring ⽤来实现 IoC 的载体， IoC 容器实际上就是个 Map （ key ， value ） ,Map 中存放的是各种对象。
将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注⼊。这样可以很⼤程度上简化应⽤的开发，把应⽤从复杂的依赖关系中解放出来。 IoC 容器就像是⼀个⼯⼚⼀样，当我们需 要创建⼀个对象的时候，只需要配置好配置⽂件 / 注解即可，完全不⽤考虑对象是如何被创建出来的。

Spring IoC有什么好处呢？

Spring IOC 容器源码分析

AOP
AOP(Aspect-Oriented Programming: ⾯向切⾯编程 ) 能够将那些与业务⽆关， 却为业务模块所共同调⽤ 的逻辑或责任（例如事务处理、⽇志管理、权限控制等）封装起来 ，便于 减少系统的重复代码 ， 降低模 块间的耦合度 ，并 有利于未来的可拓展性和可维护性 。
Spring AOP 就是基于动态代理的 ，如果要代理的对象，实现了某个接⼝，那么 Spring AOP 会使⽤ JDK Proxy ，去创建代理对象，⽽对于没有实现接⼝的对象，就⽆法使⽤ JDK Proxy 去进⾏代理了，这时候Spring AOP会使⽤ Cglib ，这时候 Spring AOP 会使⽤ Cglib ⽣成⼀个被代理对象的⼦类来作为代理，如下图所示：

Spring AOP 和 AspectJ AOP 有什么区别？

2.Spring bean

(1) 作用域

(2) Spring 中的 bean ⽣命周期

https://www.cnblogs.com/zrtqsk/p/3735273.html

Bean 容器找到配置⽂件中 Spring Bean 的定义。

Bean 容器利⽤ Java Reflection API 创建⼀个Bean的实例。

如果涉及到⼀些属性值利⽤ set() ⽅法设置⼀些属性值。

如果 Bean 实现了 BeanNameAware 接⼝，调⽤ setBeanName() ⽅法，传⼊Bean的名字。

如果 Bean 实现了 BeanClassLoaderAware 接⼝，调⽤ setBeanClassLoader() ⽅法，

传⼊ ClassLoader 对象的实例。

与上⾯的类似，如果实现了其他 *.Aware 接⼝，就调⽤相应的⽅法。

如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执

⾏ postProcessBeforeInitialization() ⽅法

如果Bean实现了 InitializingBean 接⼝，执⾏ afterPropertiesSet() ⽅法。

如果 Bean 在配置⽂件中的定义包含 init-method 属性，执⾏指定的⽅法。

如果有和加载这个 Bean的 Spring 容器相关的 BeanPostProcessor 对象，执

⾏ postProcessAfterInitialization() ⽅法

当要销毁 Bean 的时候，如果 Bean 实现了 DisposableBean 接⼝，执⾏ destroy() ⽅

法。

当要销毁 Bean 的时候，如果 Bean 在配置⽂件中的定义包含 destroy-method 属性，执⾏指定的⽅法。

3.SpringMVC

(3) Spring 框架中⽤到了哪些设计模式

面试官:"谈谈Spring中都用到了那些设计模式?"。

二.Mybatis

1.标签

2.Dao接口

3.返回与映射

4.延迟加载

三.Kafka

消息队列kafka初级

消息队列kafka高级

Kafka面试

四.设计模式

1.IO 设计模式

https://github.com/Snailclimb/JavaGuide/blob/main/docs/java/io/io-design-patterns.md

2.Spring 中的设计模式详解

https://github.com/Snailclimb/JavaGuide/blob/main/docs/system-design/framework/spring/spring-design-patterns-summary.md

https://github.com/Snailclimb/JavaGuide/blob/3965c02cc0f294b0bd3580df4868d5e396959e2e/Java%E7%9B%B8%E5%85%B3/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md

3.实践

设计模式: 实际场景的落地应用

Java设计模式及实践

JAVA设计模式的最佳实践

图说设计模式 --- Graphic Design Patterns （重点）

设计模式 | 菜鸟教程（重点）

组合模式 Java 设计模式之组合模式及应用场景 | 菜鸟教程

外观模式 JAVA设计模式之门面模式（外观模式） | 菜鸟教程

享元模式享元模式 | 菜鸟教程

代理模式代理模式 | 菜鸟教程

CGLIB(Code Generation Library) 介绍与原理 | 菜鸟教程

注意事项： 1、和适配器模式的区别：适配器模式（接口实现）主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能（扩展抽象类），而代理模式是为了加以控制。

java 复制代码

JDK 自带的动态代理

 java.lang.reflect.Proxy:生成动态代理类和对象；
 java.lang.reflect.InvocationHandler（处理器接口）：可以通过invoke方法实现
对真实角色的代理访问。

每次通过 Proxy 生成的代理类对象都要指定对应的处理器对象。

代码：

a) 接口：Subject.java

**
 * @author gnehcgnaw
 * @date 2018/11/5 19:29
 */
public interface Subject {
    public int sellBooks();

    public String speak();
}
b)真实对象：RealSubject.java

/**
 * @author gnehcgnaw
 * @date 2018/11/5 18:54
 */
public class RealSubject implements Subject{
    @Override
    public int sellBooks() {
        System.out.println("卖书");
        return 1 ;
    }

    @Override
    public String speak() {
        System.out.println("说话");
        return "张三";
    }
}
c)处理器对象：MyInvocationHandler.java

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

/**
 * 定义一个处理器
 * @author gnehcgnaw
 * @date 2018/11/5 19:26
 */
public class MyInvocationHandler implements InvocationHandler {
    /**
     * 因为需要处理真实角色，所以要把真实角色传进来
     */
    Subject realSubject ;

    public MyInvocationHandler(Subject realSubject) {
        this.realSubject = realSubject;
    }

    /**
     *
     * @param proxy    代理类
     * @param method    正在调用的方法
     * @param args      方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用代理类");
        if(method.getName().equals("sellBooks")){
            int invoke = (int)method.invoke(realSubject, args);
            System.out.println("调用的是卖书的方法");
            return invoke ;
        }else {
            String string = (String) method.invoke(realSubject,args) ;
            System.out.println("调用的是说话的方法");
            return  string ;
        }
    }
}
d)调用端：Main.java

import java.lang.reflect.Proxy;

/**
 * 调用类
 * @author gnehcgnaw
 * @date 2018/11/7 20:26
 */
public class Client {
    public static void main(String[] args) {
        //真实对象
        Subject realSubject =  new RealSubject();

        MyInvocationHandler myInvocationHandler = new MyInvocationHandler(realSubject);
        //代理对象
        Subject proxyClass = (Subject) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Subject.class}, myInvocationHandler);

        proxyClass.sellBooks();

        proxyClass.speak();
    }
}






Cglib 动态代理是针对代理的类, 动态生成一个子类, 然后子类覆盖代理类中的方法, 如果是private或是final类修饰的方法,则不会被重写。

CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。

CGLIB作为一个开源项目，其代码托管在github，地址为：https://github.com/cglib/cglib

需要代理的类:

package cn.cpf.pattern.structure.proxy.cglib;
public class Engineer {
    // 可以被代理
    public void eat() {
        System.out.println("工程师正在吃饭");
    }

    // final 方法不会被生成的字类覆盖
    public final void work() {
        System.out.println("工程师正在工作");
    }

    // private 方法不会被生成的字类覆盖
    private void play() {
        System.out.println("this engineer is playing game");
    }
}
CGLIB 代理类:

package cn.cpf.pattern.structure.proxy.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {
    private Object target;

    public CglibProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("###   before invocation");
        Object result = method.invoke(target, objects);
        System.out.println("###   end invocation");
        return result;
    }

    public static Object getProxy(Object target) {
        Enhancer enhancer = new Enhancer();
        // 设置需要代理的对象
        enhancer.setSuperclass(target.getClass());
        // 设置代理人
        enhancer.setCallback(new CglibProxy(target));
        return enhancer.create();
    }
}
测试方法:

import java.lang.reflect.Method;
import java.util.Arrays;

public class CglibMainTest {
    public static void main(String[] args) {
        // 生成 Cglib 代理类
        Engineer engineerProxy = (Engineer) CglibProxy.getProxy(new Engineer());
        // 调用相关方法
        engineerProxy.eat();
    }
}
运行结果:

###   before invocation
工程师正在吃饭
###   end invocation



CGLIB(Code Generation Library) 介绍与原理
https://www.runoob.com/w3cnote/cglibcode-generation-library-intro.html

??? 责任链模式责任链模式 | 菜鸟教程

观察者模式观察者模式 | 菜鸟教程

策略模式与状态模式的区别策略模式 VS 状态模式 | 菜鸟教程

七大原则记忆口诀：开口里合最单依

开：开闭原则

口：接口隔离原则

里：里氏替换原则

合：合成复用原则

最：最少知道原则（迪米特原则）

单：单一职责原则

依：依赖倒置原则

面试题(三)

一.Spring

1.Spring IOC & AOP

2.Spring bean

(1) 作用域

(2) Spring 中的 bean ⽣命周期

(3) Spring 框架中⽤到了哪些设计模式

二.Mybatis

1.标签

2.Dao接口

3.返回与映射

4.延迟加载

三.Kafka

四.设计模式

1.IO 设计模式

2.Spring 中的设计模式详解

3.实践