1、Docker是什么？
（1）Docker是一个快速交互、运行应用的技术，可以将程序及其依赖、运行环境一起打包为一个镜像，该镜像可以迁移到任意的Linux操作系统
（2）运行时利用沙箱机制形成隔离容器，各个应用之间互不干扰
（3）移动和移除程序都可通过一行命令完成
（4）Docker 将应用程序及其所需的依赖、函数库、环境、配置等文件打包在一起构成镜像
（5）镜像应用程序运行后形成的进程就是容器，只是 Docker 会给容器做隔离，对外不可见
2、Docker相关命令
（1）镜像命令
① 从DockerHub拉取镜像： docker pull 镜像名
② 查看所有镜像：docker images
③ 保存镜像为一个tar压缩包：docker save -o 文件名.tar 镜像名 【-o：写为文件】
④ 删除一个镜像：docker rmi 镜像名
⑤ 加载压缩包为就像：docker load -q -i 文件名.tar【-q：没有日志输出；-i：读取tar文件】
⑥ 构建镜像：docker build
⑦ 推送镜像到DockHub：docker push
（2）容器命令
① 基于镜像创建并运行容器：docker run --name containerName -p 80:80 -d 镜像名
--name：给容器起一个名字
-p：将宿主机端口与容器端口进行映射【冒号左侧是宿主机端口，右侧是容器端口】
-d：后台运行容器
② 查看所有运行的容器及其状态：docker ps
③ 查看容器运行日志：docker logs 容器ID
④ 进入容器内部执行命令（该命令不是Docker的）：docker exec -it 要进入的容器的名称 bash
-it：给当前进入的容器创建一个标准输入输出终端，允许与容器交互
bash：进入容器后执行的命令（bash是一个Linux终端交互命令）
⑤ 删除容器：docker rm（添加-f则是强制删除）
3、JDK如何实现动态代理？
（1）JDK实现动态代理必须要求被代理的类（目标类）有实现某个接口，因为JDK的代理实现逻辑就是实现目标类的接口
（2）JDK中的Proxy类有个静态方法newProxyInstance，它可以实现静态代理，它的返回值就是代理对象
（3）该方法需要一个ClassLoader类型作为参数（原因：类装载器把字节码装载到JVM后，类装载器会解析字节码，并生成对应字节码的Class对象。每个类都有一个Class对象，一个类能够被实例化的条件是必须有Class对象，Class对象中包含了类的完整信息）
（4）动态代理也叫做动态字节码，字节码在运行时生成，类装载器直接通过运行时生成的字节码创建该字节码的Class对象（减少了装载class文件的过程）
（5）newProxyInstance方法还需要一个Class对象数组（它是目标类实现的接口的Class对象数组），可通过目标类的getInterfaces方法获取
（6）附加代码通过newProxyInstance方法的第三个参数传入，第三个参数可以传入匿名类或InvocationHandler接口的实现类
（7）InvocationHandler接口中invoke方法的第一个参数proxy是代理对象；第二个参数的参数类型是Method，它是目标方法；第三个参数args是目标方法的参数
（8）bean生命周期的BeanPostProcessor可统一处理所有的bean，可在该生命周期中为指定的bean创建代理对象（增加额外功能）
（9）JDK的方式实现动态代理的缺点：假如目标类没有实现任何接口，则无法通过JDK的方式实现动态代理【可通过CGLib进行实现】
（10）MyBatis的SqlSession对象的getMapper方法传入Dao的类对象后可返回Dao的代理对象，MyBatis使用的是JDK的动态代理实现
/** * 使用BeanPostProcessor生命周期为指定bean生成代理对象 * 目的是：为Bean增加日志打印的功能 */ public class LogProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { Class<?> beanCls = bean.getClass(); Class<?>[] interfaceArr = beanCls.getInterfaces(); // 如果当前bean没有实现过接口: 无法通过JDK的方式为其增加额外功能 if (interfaceArr.length < 1) return bean; return Proxy.newProxyInstance( getClass().getClassLoader(), interfaceArr, new LogInvocationHandlerImpl(bean) ); } /** * 实现InvocationHandler接口, 重写它的invoke方法（编写附加代码） */ private static class LogInvocationHandlerImpl implements InvocationHandler { private final Object targetBean; public LogInvocationHandlerImpl(Object targetBean) { this.targetBean = targetBean; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("LogInvocationHandlerImpl 附加代码1"); Object retVal = method.invoke(targetBean, args); System.out.println("LogInvocationHandlerImpl 附加代码2"); return retVal; } } }
4、CGLib如何实现动态代理？
（1）CGLib在Spring框架中已有集成，它的实现逻辑是：让代理类继承目标类
（2）创建CGLib库的Enhancer类的实例，并设置类加载器、设置目标类的类对象、通过MethodInterceptor接口设置附加代码，最后调用该实例的create方法
（3）bean生命周期的BeanPostProcessor可统一处理所有的bean，可在该生命周期中为指定的bean创建代理对象（增加额外功能）
（4）CGLib相比JDK的动态代理实现方案比较灵活，不要求目标类必须实现接口
/** * 通过CGLib的方式为指定目标类的目标方法增加额外功能, 生成该目标类的代理类 */ public class LogProcessorByCGLib implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { Enhancer enhancer = new Enhancer(); // 设置类加载器 enhancer.setClassLoader(getClass().getClassLoader()); // 设置目标类 enhancer.setSuperclass(bean.getClass()); // 设置目标代码 enhancer.setCallback(new LogMethodInterceptorImpl(bean)); return enhancer.create(); // 创建代理类 } /** * 实现MethodInterceptor接口, 增加附加功能 * MethodInterceptor是Callback接口的子接口 */ private static class LogMethodInterceptorImpl implements MethodInterceptor { private final Object targetBean; public LogMethodInterceptorImpl(Object targetBean) { this.targetBean = targetBean; } @Override public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("LogMethodInterceptorImpl 日志1"); // 调用目标方法 Object retVal = method.invoke(targetBean, args); System.out.println("LogMethodInterceptorImpl 日志2"); return retVal; } } }
5、Bean的生命周期
（1）构造方法
（2）setter
（3）BeanNameAware接口的setBeanName方法
（4）ApplicationContextAware接口的setApplacationContext方法
（5）BeanPostProcessor接口的postProcessBeforInitialization方法
（6）InitializingBean接口的afterPropertiesSet方法
（7）配置文件中的init-method属性的方法
（8）BeanPostProcessor接口的postAfterInitialization方法
（9）业务方法
（10）DisposableBean接口的destroy方法
（11）配置文件中的destroy-method属性的方法
若配置文件中bean标签的scope属性是singleton，且容器销毁，才会出发第10和第11个方法
6、AOP是什么？
（1）AOP是Aspect Oriented Programming的简称。
（2）使用AOP技术可以很精确地为某些类的某些方法增加额外功能。虽然JDK的动态代理和CGLib也可以控制为某些类的某些方法增加功能，但判断很多，代码比较复杂。
（3）AOP依赖两个库：aspectjrt和aspectjweaver
（4）附加代码可通过两个接口编写：MethodBeforeAdvice接口和MethodInterceptor接口
（5）若有配置文件的话，需在配置文件中配置切入点和附加代码结合【在<aop:config>标签中配置切入点和切入点与附加代码的结合；在<aop:pointcut>标签中配置切入点；在<aop:advisor>标签中配置切入点和附加代码的结合】
（6）通过MethodBeforeAdvice接口只能在目标方法之前执行附加代码；MethodInterceptor接口则可以在目标方法之前或之后执行附加代码
<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> <version>1.9.6</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version> </dependency>
/** * 实现MethodBeforeAdvice接口, 在该接口的before方法中编写AOP的附加代码 */ public class LogMethodBeforeAdvice implements MethodBeforeAdvice { @Override public void before(Method method, Object[] args, Object o) throws Throwable { System.out.println("LogMethodBeforeAdvice_before: " + Arrays.toString(args)); } }
/** * 通过实现org.aopalliance.intercept.MethodInterceptor接口添加附加代码 */ public class LogMethodInterceptor implements MethodInterceptor { @Override public Object invoke(MethodInvocation methodInvocation) throws Throwable { System.out.println("LogMethodInterceptor_附加代码1"); Object retVal = methodInvocation.proceed(); System.out.println("LogMethodInterceptor_附加代码2"); return retVal; } }
<!-- 附加代码 --> <bean id="logMethodBeforeAdvice" class="com.guoqing.aop.LogMethodBeforeAdvice"/> <aop:config> <!-- 配置切入点 --> <!-- 切入任意方法 --> <aop:pointcut id="pointcut1" expression="execution(* *(..))"/> <!--切入方法名以【Impl】结尾的方法 --> <aop:pointcut id="pointcut2" expression="execution(* *Impl(..))"/> <!-- 在切入点pointcut1处添加附加代码logMethodBeforeAdvice --> <aop:advisor advice-ref="logMethodBeforeAdvice" pointcut-ref="pointcut1"/> </aop:config>
切入点表达式
🍀 ① 任意公共方法：
execution(public * *(..))
🍀 ② 方法名以 set 开头的全部方法：
execution(* set*(..))
🍀 ③ UserService 接口定义的全部方法：
execution(* com.guoqing.service.UserService.*(..))
🍀 ④ service 包下定义的全部方法（不包括子包）：
execution(* com.guoqing.service.*.*(..))
🍀 ⑤ service 包下定义的全部方法（包括子包）：
execution(* com.guoqing.service..*.*(..))
🍀 ⑥ 包含两个 String 类型参数的全部方法：
execution(* *(String, String))
🍀 ⑦ 只有一个 Serializable 参数的全部方法：
args(java.io.Serializable)
🍀 ⑧ service 包中的全部方法：
within(com.guoqing.service.*)
🍀 ⑨ service 包中的全部方法（包括子包）：
within(com.guoqing.service..*)
7、AOP的底层实现？
（1）AOP的底层是用JDK或CGLib实现的。若目标类有实现接口，则使用JDK的动态代理技术实现；若目标类没有实现接口，则使用CGLib实现
（2）AOP的底层是在BeanPostProcessor生命周期的postProcessAfterInitialization方法中创建代理对象
（3）底层的AbstractAutowireCapableBeanFactory类中的applyBeanPostProcessorsAfterInitialization方法会遍历所有的BeanPostProcess并执行它们的postProcessBeforeInitialization方法，代理对象也是在此处产生的【参考】
（4）可以通过proxy-target-class属性修改AOP的动态代理的底层实现方案（true：强制使用CGLib；false：按照默认的做法）
8、目标方法相互调用只会被切入一次
（1）默认情况下，目标方法相互调用的时候总共只会被切入一次。
（2）解决办法：拿到代理对象调用目标方法
（3）如何拿到代理对象？通过ApplicationContextAware拿到IoC容器；通过BeanNameAware拿到bean的名字；通过容器的getBean方法和bean的名字获取当前代理对象
public class UserServiceImpl implements UserService, ApplicationContextAware, BeanNameAware { private String beanName; private ApplicationContext ctx; public boolean login(String username, String password) { System.out.println("login_" + username + "_" + password); // 拿到代理对象 UserService proxyObj = (UserService) ctx.getBean(beanName); // 代理对象调用目标方法 proxyObj.register(username, password, "16685", "520112"); return false; } public boolean register(String username, String password, String phone, String idCard) { System.out.println("register_" + username + "_" + password + "_" + phone + "_" + idCard); return false; } @Override public void setBeanName(String name) { beanName = name; } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { ctx = applicationContext; } }
9、Spring常用注解有哪些？
（1）假如应用的入口依然是xml文件的话，需要在xml文件中配置包扫码（<context:component-scan>）【@ComponentScan注解的作用和该标签一样，可以扫描到所有的@Component，还可使用@ComponentScans注解配置多个需要扫码的包】
（2）@Component注解：相当于配置文件中的bean标签【可通过该注解的value属性设置ID，默认ID是将类名的首字母小写】
（3）@Controller用于标识控制层；@Service用于标识业务层；@Repository用于标识DAO层【这些注解和@Component注解的作用一样，只是名字不一样】
（4）@Scope：相当于bean标签中的scope属性
（5）bean标签中的lazy-init属性的作用是当某个bean第一次被使用的时候才创建该bean的实例（默认是IoC容器创建的时候创建）【@Lazy注解作用一样】
（6）@Autowired可按照类型注入bean实例，可以写在成员变量上（不会调用setter）、setter上【可以拿@Autowired配合@Qualifier设置注入的bean的ID名，当@Autowired的required属性的值是false的时候，找不到bean时不会抛异常】
（7）@Value用于注入String、基本类型、BigDecimal等类型
（8）@PropertySource、@PropertySources可读取配置文件中的内容，然后通过@Value注解和 ${name} 语法注入配置文件的内容【该注解类似于 <context:property-placeholder> 标签】
10、注解实现AOP？
（1）导入aspectjrt和aspectjweaver两个依赖
（2）配置切面类（也就是附加代码），在切面类上添加@Aspect和@Component
（3）切面类中的方法的返回值必须是Object，方法名任意，必须有ProceedingJoinPoint类型的参数，必须抛出Throwable类型的异常（通过参数的proceed方法调用目标方法）
（4）在方法上通过@Around注解配置切入点
（5）@Pointcut注解可以抽取切入点（使得该切入点可以重复使用）
（6）假如有配置文件，必须添加<aop:aspect-autoproxy />标签，该标签类似<aop:config>标签
（7）若没有配置文件（想要纯注解），可添加@EnableAspectJAutoProxy注解（该注解相当于<aop:aspect-autoproxy />标签）
@Component @Aspect // 表示当前类是一个切面类 public class LogAspect { @Pointcut("execution(* *(..))") private void pointcut() {} // @Around("execution(* *(..))") @Around("pointcut()") public Object log(ProceedingJoinPoint pjp) throws Throwable { System.out.println("log---------1"); Object ret = pjp.proceed(); System.out.println("log---------2"); return ret; } // @Around("execution(* *(..))") @Around("pointcut()") public Object watch(ProceedingJoinPoint pjp) throws Throwable { System.out.println("watch---------1"); Object ret = pjp.proceed(); System.out.println("watch---------2"); return ret; } }
11、@Configuration和@Bean注解有啥作用？
（1）使用@Configuration的类可以取代applicationContext.xml配置文件，该注解也是一个@Component，所以可以通过component-scan扫描
（2）@Bean注解用在被@Configuration注解注解的类中，用于修饰方法，进行bean对象的创建【默认情况下方法名就是bean的ID，也可以通过name或value属性设置bean的ID，可以配置@Scope设置bean的创建次数】
（3）可以通过实现 FactoryBean 接口把创建过程比较复杂的对象放入IoC容器，实现FactoryBean接口，重写该接口的getObject方法（在该方法中编写创建复杂对象的代码）；在配置文件通过bean标签或 @Configuration和@Bean 注入对象的时候，当发现该类实现（implements）了FactoryBean接口的时候，会自动调用getObject方法（把该方法的返回值放入IoC容器）；若的确想拿到实现FactoryBean的实现类，而不是getObject的返回值，可在获取bean（如调用容器的getBean方法的时候在ID前面加&符号）
public class DogFactoryBean implements FactoryBean<Dog> { @Override public Dog getObject() throws Exception { Dog dog = new Dog(); dog.setName("小狗"); return dog; } @Override public Class<?> getObjectType() { return Dog.class; } }
public class MyTest { @Test public void t() { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); Object dog1 = ctx.getBean("dog"); Object dog2 = ctx.getBean("&dog"); // dog1 = Dog{name='小狗'} System.out.println("dog1 = " + dog1); // dog2 = com.guoqing.myfactorybean.DogFactoryBean@52e6fdee System.out.println("dog2 = " + dog2); } }
@Configuration public class BeanConfiguration { @Bean public DogFactoryBean dog() { // 实际会调用DogFactoryBean的getObject()方法 return new DogFactoryBean(); } }
12、创建Spring工厂的入口有哪些？
（1）如果创建工厂的入口是xml文件，一般就用ClassPathXmlApplicationContext类【可以使用<context:component-scan>标签扫描注解信息；可以使用<import resource="" />标签导入其他配置文件】
（2）如果希望创建工厂的入口是注解（希望纯注解开发），使用AnnotationConfigApplicationContext类，使用该类创建工厂的时候需要传入一个类（传入该类的构造方法中的类默认会被放入IoC容器）
（3）可以用@ImportResource注解引入XML配置文件
13、Spring bean的三种创建方式
（1）@Component：常用于源码可修改、创建过程比较简单（直接调用构造方法即可）的类型
（2）@Bean：用于源码不可修改（如第三方库的类型）或者创建过程比较复杂的类型
（3）配置文件<bean>标签：适用于全部类型（优先级最高）
当上述三种方式创建的bean的ID相同时，优先级最高的是<bean>标签、优先级第二的是@Bean、@Component的优先级最低【<bean>标签的方式可用于覆盖以前@Bean、@Component的内容，减少对@Bean、@Component代码的修改】
14、什么是JSR注解
（1）JSR是Java Specification Requests的缩写（Java规范提案）
（2）任何人都可以向JCP（Java Community Process）提出一个JSR，以向Java平台增添新的API或服务
（3）一旦某个JSR通过了JCP的审核，该JSR就变成了Java技术栈的一部分，Spring中也支持JSR规范中定义的一些注解（这些注解是Java技术栈提供的，不是Spring提供的注解）
（4）JSR 250（250是一个编号）的 @Resource 注解可根据名称注入bean（可用在成员变量或setter上；若没有指明名称，作用和@Autowired一样）【Spring的@Autowired是根据类型进行注入，若想根据名称进行注入需要配合@Qualifier注解使用】
（5）JSR 330的 @Inject 注解：按照类型注入，可用在属性、setter、构造方法上（可以配置@Named设置注入的bean的ID）
（6）JSR 520的 @PostConstruct 注解（在InitializingBean的afterPropertiesSet方法之前调用）和 @PreDestroy 注解（在DisposableBean的destroy方法之前调用）
（7）使用@Inject注解需要导java.inject包；使用@Resource、@PostConstruct和@PreDestroy注解需要导java.annotation-api包
<!-- @Resource、@PostConstruct、@PreDestroy --> <dependency> <groupId>javax.annotation</groupId> <artifactId>javax.annotation-api</artifactId> <version>1.3.2</version> </dependency> <!-- @Inject --> <dependency> <groupId>javax.inject</groupId> <artifactId>javax.inject</artifactId> <version>1</version> </dependency>
@Inject public Person(@Named("niceDog") Dog dog, @Nullable String name) { System.out.println("有参构造_" + name); this.dog = dog; }
15、@PropertySource的底层类
该注解的底层类是PropertySourcesPlaceholderConfigurer，也可通过该类实现配置文件的注入
@Configuration public class MyBeanConfig { @Bean public PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() { PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer(); configurer.setLocation(new ClassPathResource("child.properties")); return configurer; } }
16、SpringMVC简介
（1）SpringMVC的正式名称是Spring Web MVC（属于Spring框架的一部分），是基于Servlet API构建的Web框架
（2）SpringMVC的核心功能是拦截和处理客户端的请求
