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

简介: 【面试题】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)若有配置文件的话,需在配置文件中配置切入点和附加代码结合【在<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的核心功能是拦截和处理客户端的请求

相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
相关文章
|
24天前
|
缓存 前端开发 Java
Spring MVC 面试题及答案整理,最新面试题
Spring MVC 面试题及答案整理,最新面试题
81 0
|
2月前
|
JSON 前端开发 Java
都说Spring MVC面试问烂了,可是很多人工作三年还是不懂!
大家找工作时,涉及框架面试问题时,常会被问及框架的原理及工作流程。所以本 Chat 通过带着大家一起来自己写一个 Struts2 框架(同理SpringMVC框架 ),亲身体验下框架的实现流程及工作原理!
30 0
|
2月前
|
消息中间件 Java Kafka
Spring Boot面试题
Spring Boot 是一套快速开发框架,随着微服务架构应用不断普及,Spring Boot 的研发技术的掌握已经成为研发人员必会技能。与此同时,Spring Boot 开源生态建设能力非常强大,提供了很多应用组件,让Spring Boot 有丰富的三方开源软件的使用。
63 0
Spring Boot面试题
|
2月前
|
前端开发 Java 程序员
Spring MVC面试题
Spring MVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级 Web框架,通过把模型-视图-控制器分离,将web层进行职责解耦,把复杂的 web应用分成逻辑清晰的几部分,简化开发,减少出错,方便组内开发人员之间的配合。
73 1
Spring MVC面试题
|
24天前
|
缓存 安全 Java
Spring Boot 面试题及答案整理,最新面试题
Spring Boot 面试题及答案整理,最新面试题
104 0
|
24天前
|
负载均衡 Java API
Spring Cloud 面试题及答案整理,最新面试题
Spring Cloud 面试题及答案整理,最新面试题
122 1
|
2月前
|
监控 Java Docker
从零开始,用Docker-compose打造SkyWalking、Elasticsearch和Spring Cloud的完美融合
从零开始,用Docker-compose打造SkyWalking、Elasticsearch和Spring Cloud的完美融合
353 0
|
24天前
|
Java Nacos Sentinel
Spring Cloud Alibaba 面试题及答案整理,最新面试题
Spring Cloud Alibaba 面试题及答案整理,最新面试题
119 0
|
2月前
|
存储 缓存 Java
明知面试要问spring循环依赖,很多人还是搞不懂!
Spring中的循环依赖一直是Spring中一个很重要的话题,一方面是因为源码中为了解决循环依赖做了很多处理,另外一方面是因为面试的时候,如果问到Spring中比较高阶的问题,那么循环依赖必定逃不掉。如果你回答得好,那么这就是你的必杀技,反正,那就是面试官的必杀技,这也是取这个标题的原因,当然,本文的目的是为了让你在之后的所有面试中能多一个必杀技,专门用来绝杀面试官!
30 0
|
24天前
|
前端开发 安全 Java
Spring 面试题及答案整理,最新面试题
Spring 面试题及答案整理,最新面试题
73 3