【面试题】2、Docker和Spring相关

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）若有配置文件的话，需在配置文件中配置切入点和附加代码结合【在标签中配置切入点和切入点与附加代码的结合；在标签中配置切入点；在标签中配置切入点和附加代码的结合】
（6）通过MethodBeforeAdvice接口只能在目标方法之前执行附加代码；MethodInterceptor接口则可以在目标方法之前或之后执行附加代码

   <dependency>
       <groupId>org.aspectjgroupId>
       <artifactId>aspectjrtartifactId>
       <version>1.9.6version>
   dependency>
   <dependency>
       <groupId>org.aspectjgroupId>
       <artifactId>aspectjweaverartifactId>
       <version>1.9.6version>
   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(* *(..))"/>
     
     <aop:pointcut id="pointcut2" expression="execution(* *Impl(..))"/>

     
     <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文件中配置包扫码（）【@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} 语法注入配置文件的内容【该注解类似于 标签】

10、注解实现AOP？

（1）导入aspectjrt和aspectjweaver两个依赖
（2）配置切面类（也就是附加代码），在切面类上添加@Aspect和@Component
（3）切面类中的方法的返回值必须是Object，方法名任意，必须有ProceedingJoinPoint类型的参数，必须抛出Throwable类型的异常（通过参数的proceed方法调用目标方法）
（4）在方法上通过@Around注解配置切入点
（5）@Pointcut注解可以抽取切入点（使得该切入点可以重复使用）
（6）假如有配置文件，必须添加标签，该标签类似标签
（7）若没有配置文件（想要纯注解），可添加@EnableAspectJAutoProxy注解（该注解相当于标签）

@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类【可以使用标签扫描注解信息；可以使用标签导入其他配置文件】
（2）如果希望创建工厂的入口是注解（希望纯注解开发），使用AnnotationConfigApplicationContext类，使用该类创建工厂的时候需要传入一个类（传入该类的构造方法中的类默认会被放入IoC容器）
（3）可以用@ImportResource注解引入XML配置文件

13、Spring bean的三种创建方式

（1）@Component：常用于源码可修改、创建过程比较简单（直接调用构造方法即可）的类型
（2）@Bean：用于源码不可修改（如第三方库的类型）或者创建过程比较复杂的类型
（3）配置文件标签：适用于全部类型（优先级最高）

当上述三种方式创建的bean的ID相同时，优先级最高的是标签、优先级第二的是@Bean、@Component的优先级最低【标签的方式可用于覆盖以前@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包

   
   <dependency>
       <groupId>javax.annotationgroupId>
       <artifactId>javax.annotation-apiartifactId>
       <version>1.3.2version>
   dependency>

   
   <dependency>
       <groupId>javax.injectgroupId>
       <artifactId>javax.injectartifactId>
       <version>1version>
   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的核心功能是拦截和处理客户端的请求