面試就业题库-04

Posted 小码哥的进阶

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面試就业题库-04相关的知识,希望对你有一定的参考价值。

文章目录

1. java基础(1)

2. javaweb(1)

2.1 javaweb三大组件: Servlet, Filter, Listener

  • Servlet作用: 接收请求和响应数据到客户端.
  • Filter作用: 拦截请求和响应.场景: 处理全局的中文乱码问题,权限校验,加载配置文件等操作
    实现拦截资源: 静态资源(html, css, js, 图片等等)和动态资源(后台与客户端交互的类,比如: controller)都会拦截
    配置拦截路径: 1. /资源名称 2. /* 拦截所有资源 3. .扩展名, 比如: .html,
  • Listener作用: 监听对象状态的改变,以及加载配置文件.

2.2 Servlet特点,线程是否安全

 * Servlet是单例的(Servlet对象在内存中只有一个,所有请求访问的是同一个servlet)
 * Serlet是线程不安全的.不能避免,尽量减少安全问题
  在servlet里面尽量避免定义成员变量.
* 说明: 凡是单例对象,总是存在线程安全问题,为了减少或者尽量避免安全问题, 在单例类避免定义成员变量. 
* servlet和springmvc什么关系?
1. springmvc底层: 封装的servlet
2. springmvc中央控制器: 就是一个servlet,分发浏览器的请求.

2.3 Filter过滤器作用是什么, 后面学习的springmvc有什么关系, 和springmvc的拦截器的区别?

  • 自定义过滤器: 实现Filter接口,
    有个方法doFilter(req, response): 拦截请求和响应,放行: Filterchain对象放行方法
  • SpringMVC大量用到了过滤器,
  • 比如: CharacterEncodingFilter, 处理乱码问题,以及加载springmvc的配置文件.
  • 过滤器和springmvc的拦截器有关系有什么区别?
  1. 过滤器是web是三大组件之一,基于web开发环境(web项目).
  2. springmvc的拦截器和过滤器没有关系,拦截器实现基于代理(默认jdk动态代理)方式实现的.

2.4 Listener的分类, 作用是什么,后期那些框架里面用到了监听器?

  • 自定义一个监听器: 实现Listener接口
  • 监听器:分为三大类,八个监听器.
  • 监听器: 在spring框架里面,springmvc框架里面使用,springboot框架里面.
    *比如: spring框架,使用ContextLoaderListener在web服务器启动时,读取spring配置文件,初始化bean对象,装配到spring容器中(ConCurrentHashMap)

2.5 Cookie 和 Session 区别以及使用场景?

    1. Cookie 和Session是会话管理技术
    1. 会话概述
      指的一个用户从打开一个浏览器开始,访问网站,直到这个用户关闭浏览器,这个完整的过程就是一次会话.
      细节1: 一个用户打开了两个浏览器,比如: firefox ,chrome , 用户开启了两个会话
      细节2: 一个用户打开一个浏览器,访问网站,打开了好多个网页, 关闭了其中一个网页,表示会话结束,这是错误的说法
      细节3: 一个用户打开一个浏览器,访问网站,直到用户关闭浏览器,表示会话结束,等用户下次在打开浏览器进行访问
      重新开启一次新的会话
      总结: 一次完整的会话始终对应一个用户.
  • 2.Cookie
    2.1. Cookie客户端技术, Cookie数据在客户端(浏览器或者手机app)保存
    2.2. Cookie对象是在服务器端,创建cookie对象,设置数据,响应给浏览器
    2.3. 当浏览器首次访问服务器端时,浏览器是不会提交cookie到服务器端
    2.4. Cookie常用api
    ==创建cookie对象: Cookie c = new Cookie(String key, String value);
    ==cookie的路径: setPath()
    ==cookie的域名: setDomain()
    ==cookie的时长: setMaxAge(int seconds)
    2.5 cookie的类型分为三类
    • 浏览了器cookie: 对cookie时长不做处理, 当浏览器关闭,cookie对象会自动销毁
    • “杀死cookie”: 将cookie的setMaxAge(0),同时响应到客户端
    • 持久化cookie: 将cookie的setMaxAge(3600247),cookie可以在浏览器保存7天, 同时响应到客户端
      2.6 面试问题
      2.6.1 浏览器首次访问网站是, 不会提交cookie到服务器端。
      因为cookie在服务器端创建的,创建以后才会响应到浏览器端保存。
      2.6.2 浏览器什么时候提交cookie?
      * cookie的默认域名: 当前浏览器地址中的域名,
      * cookie的默认路径: /
      * 浏览器的访问地址: 比如: http://localhost:8080/demo1Cookie, 域名: localhost ,端口:8080,路径:demo1Cookie
      * 结论: 浏览器的访问地址包含了cookie的路径以及域名,浏览器就会提交cookie.
      比如: url = http://localhost:8080/demo2/cookie 浏览器的访问地址, cookie: 路径 / 域名是localhost
      url包含路径/, 包含域名localhost, 可以通过浏览器提交cookie到服务器端.
      比如: url = http://localhost:8080/demo2/cookie 浏览器的访问地址, cookie: 路径 /ddd 域名是localhost
      url没有包含路径/ddd, 不可以通过浏览器提交cookie到服务器端.
      2.6.3 cookie开发中应用场景.
      结论: 开发中功能凡是需要在客户端获取数据的, 我们就可以使用cookie.
      企业开发中:
      1.登录页面回显用户, 可以使用cookie保存用户
      2.单点登录时, 可以使用cookie保存登录的认证信息,通过浏览器提交cookie在认证管理器进行认证。
      3.显示用户的浏览记录: 记录数据使用cookie。
      4.等等。
  • 3.Session
    • 3.1 Session是服务器端会话管理技术, 在服务器端通过session保存数据
    • 3.2 一次会话始终对应一个session
    • 3.3 Session底层原理: 依赖与浏览器级别的cookie实现。
      浏览器级别的cookie的名称: JESSSIONID, cookie的值:session.getId().
      流程:
    1. 用户首次访问服务器端,在服务器端创建一个session对象
      同时服务器会自动为当前的session创建一个特殊的cookie:(名称: JESSIONID, 值:当前session.getId())
      session.getId()称之为钥匙, "找"session
    2. 下次访问,浏览器会提交这个特殊cookie到服务器端,服务器会自动解析Cookie,拿到"钥匙",根据"钥匙"找到session
      可以使用session里面的数据
    3. 如果开启一次新的会话,这个特殊的cookie(浏览器级别的cookie)就会销毁了,找不到session.

3.3 Session的应用场景

  • 购物车数据: (Session+数据库)保存购物车数据
  • 简单权限校验: 判断当前会话是不是一个用户(一次会话对应一个用户,其实也对应一个session)
  • 防止表单的重复提交
    比如: 用户在银行转账时,在当前转账页面不管点击多少次转账,只允许一次转账.
  • 单点登录session(session不能跨域): redis+session
  • 等等
    防止表单重复提交,案例分析:

3. ssm+springboot+springCloud(1.5)

3.1 Spring框架

3.1.1 BeanFactory 和 ApplicationContext 有什么区别

-容器的体系结构

  • java普通项目:需要手动创建容器对象,读取配置文件或者扫描注解,创建bean对象装配到容器中
  • java的web项目: 通过监听器自动创建容器对象,读取配置文件或者扫描注解,创建bean对象装配到容器中
  • BeanFactory和ApplicationContext都是接口,

    并且ApplicationContext是BeanFactory的子接口。

    同时它们都是spring的容器对象

    作用:

    1. 读取配置文件 或者扫描注解

    2. 创建bean对象,装配到容器(ConCurrentHashMap)

      ConCurrentHashMap保存bean对象:

      情况一: map的key: bean类的名称(类名首字母小写)

      ​ map的value: bean的对象

      情况二:map的key: bean类的class字节码

      ​ map的value: bean的对象

  • BeanFactory是Spring中最底层的接口,提供了最简单的容器的功能,只提供了实例化对象和拿对象的功能。而ApplicationContext是Spring的一个更高级的容器,提供了更多的有用的功能。

  • ApplicationContext提供的额外的功能:国际化的功能、消息发送、响应机制、统一加载资源的功能、强大的事件机制、对Web应用的支持等等。

  • 加载方式的区别:BeanFactory采用的是延迟加载的形式来注入Bean;ApplicationContext则相反的,它是在Ioc启动时就一次性创建所有的Bean,好处是可以马上发现Spring配置文件中的错误,坏处是造成浪费

3.1.2 Spring两大核心

3.1.2.1. 怎么理解spring的ioc?

= IOC:inverse of controller 控制反转, 把创建bean对象的权力反转给spring容器管理.
= spring容器怎么创建bean对象?
说明: spring容器,这个容器指的就是ConCurrentHashMap
1.基于配置文件开发spring.
在构建spring容器对象时,通过Dom4j解析spring的配置文件(读文件的过程),得到类的全路径,
根据反射创建bean对象(class.newInstance(),默认是使用bean的无参数的构造方法)
向map集合put对象
方式一: map的key: bean类名首字母小写, map的value: bean对象
方式二: map的key: bean的class字节码, map的value: bean对象
比如:

2.基于注解开发
在构建spring容器对象时, 通过扫描包下面的注解(@ComponentScan) ,看下那些包下面有注解
@Component, @Service, @Repository, 获取到该注解下面的类的全路径,利用反射创建bean对象(class.newInstance(),默认是使用bean的无参数的构造方法)

   @Component
	@Scope("singleton")
	@Lazy(true)// lazy-init=true, 懒加载, false=立即加载
	public class Cat 
	

3.1.2.2. Spring的IOC创建bean对象,采用了那些常用的设计模式

  • 单例模式: 作用在内存中保证只有一个实例对象
  • 工厂模式: 作用构建对象,在spring里面,工厂就是创建bean对象
    工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。
    这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
    在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
    通俗的来讲就是:
    原来需要我们自己做自己创建的对象现在不需要我们做了,我们只需要向工厂要,你需要什么,工厂给你什么(指 的:通过工厂创建对象,降低耦合度)。
#bean.properties
	dog=cn.spring_case.Dog
	package cn.factory_model;

import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 比如: 富士康工厂,生产手机的
 * 原材料----->工厂流水线------->手机产品
 * 开发,使用工厂模式
 *  元信息---->工厂----------->bean对象
 */
public class BeanFactory 
    //0.创建容器对象
    static  Map<Object,Object> map = new ConcurrentHashMap<>();
    //1.读取bean.properties
    static 
        try 
            //1.1 字节输入流
            InputStream in = BeanFactory.class.getClassLoader().
                    getResourceAsStream("bean.properties");
            //1.2加载字节流
            Properties p = new Properties();
            p.load(in);
            //1.3.根据名称 获取类的全路径
            String classPath = p.getProperty("dog");//cn.tedu.Dog
            //1.4 利用反射创建对象
            Class aClass = Class.forName(classPath);//Dog.class
            //1.5 利用无参的构造创建对象
            Object bean = aClass.newInstance();// new Dog()
            //1.6.创建bean对象,设置到容器中
            map.put("dog",bean);// dog -->bean
            map.put(aClass,bean);//dog.class->bean
         catch (Exception e) 
            e.printStackTrace();
        
    
    //2.根据名称获取bean对象
    public  static Object getBean(String name)
        return map.get(name);// dog -->bean
    
    //3.根据class获取bean对象
    public static <T> T getBean(Class clz)
        return  (T)map.get(clz);
    

  • 适配器模式:
    ==介绍:
    将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。
    ==解决的问题: 原本由于接口不兼容而不能一起工作的那些类可以在一起工作
    == 适配器的应用场景:
    比如:
    (1)JDK源码的IO模块用到,
    例 java.io.InputStreamReader(InputStream)、java.io.OutputStreamWriter(OutputStream)。
    (2)mybatis源码日志模块用到对象适配器模式。
    ==通常企业开发适用于以下场景。
    以前开发的系统存在满足新系统功能需求的类,但其接口同新系统的接口不一致。
    使用第三方提供的组件,但组件接口定义和自己要求的接口定义不同。

  • 模板模式

  • 等等

3.1.3 怎么理解spring的aop?

3.1.3.1 AOP常见术语

3.1.3.2. 通知

  • 前置通知(Before advice) :在某连接点(JoinPoint)之前执行的通知,但这个通知不能阻止连接点前的执行。ApplicationContext中在aop:aspect里面使用aop:before元素进行声明。

  • 后通知(After advice) :当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)。ApplicationContext中在aop:aspect里面使用aop:after元素进行声明。

  • 返回后通知(After return advice) :在某连接点正常完成后执行的通知,不包括抛出异常的情况。ApplicationContext中在aop:aspect里面使用元素进行声明。

  • 环绕通知(Around advice) :包围一个连接点的通知,类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为,也可以选择不执行。ApplicationContext中在aop:aspect里面使用aop:around元素进行声明。

  • 抛出异常后通知(After throwing advice) : 在方法抛出异常退出时执行的通知。 ApplicationContext中在aop:aspect里面使用aop:after-throwing元素进行声明。

  • 切入点表达式 :如execution(* com.spring.service..(…))

3.1.3.3 SpringAOP原理

  1. SpringAOP: 本质就是对业务类中的方法进行增强.

  2. 动态代理设计模式: 本质就是对类中的方法进行增强

    • jdk: 基于接口代理(spring默认使用)
      代码实现
  public interface LenvenInterface 
  //卖电脑:6000
  int sellComputer(int m );
 
public class ProxyLenven 
  @Test
  public void testX()
      //1.参数1类加载器: 应用类加载器
      ClassLoader loader = ProxyLenven.class.getClassLoader();
      //2.参数2接口数组: jdk代理,基于接口代理
      Class[] interfaces = LenvenInterface.class;
      // 创建一个卖电脑的对象
      LenvenInterface target = new LenvenInterface() 
          @Override
          public int sellComputer(int m) 
              return m;
          
      ;
      //3.参数3 增强器对象
      InvocationHandler handler = new InvocationHandler() 
          // proxy: 代理对象
          // method: 增强的方法,反射对象
          // args: 方法中的参数
          public Object invoke(Object proxy,
                               Method method,
                               Object[] args) throws Throwable 
              //1.前置通知
              System.out.println("car recevice--");
              //2.卖电脑的方法
              int money = (int)method.invoke(target,args);// target.sellComputer(8000)
              System.out.println("sell computer");
              //3.后置通知
              System.out.println("car send---");
              //4.卖完电脑以后,给代理商预留2000: 执行方法后的通知增强
              int  kouxia = money-6000;
              return kouxia;
          
      ;
      LenvenInterface proxy=(LenvenInterface) Proxy.
              newProxyInstance(loader,interfaces,handler);

      int money = proxy.sellComputer(8000);
      System.out.println("proxy:"+money);


  

  • cglib: 基于类代理

3.1.3.4. 通知. SpringAOP底层: 依赖动态代理进行增强.

细节: 默认使用JDK的代理方式(java原生), 如果业务类没有接口,显示指定cglib代理

3.1.3.5. SpringAOP的应用场景

  • 事务管理: @Transaction

  • 日志记录: log4j ,动态日志记录,

    比如: 银行系统需要记录银行职员操作系统的日志

    比如: 通过aop对业务类进行增强,记录职员的操作时间,操作方法,操作参数,操作人等

  • 安全管理

3.1.4. 事务的传播属性

  • Propagation :key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用:
  • PROPAGATION_REQUIRED: 支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。
  • PROPAGATION_SUPPORTS: 支持当前事务,如果当前没有事务,就以非事务方式执行。
  • PROPAGATION_MANDATORY: 支持当前事务,如果当前没有事务,就抛出异常。
  • PROPAGATION_REQUIRES_NEW: 新建事务,如果当前存在事务,把当前事务挂起。
  • PROPAGATION_NOT_SUPPORTED: 以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
  • PROPAGATION_NEVER: 以非事务方式执行,如果当前存在事务,则抛出异常。

3.1.5.spring框架的优缺点

  • Spring 的优点
    • 降低了组件之间的耦合性 ,实现了软件各层之间的解耦
    • 可以使用容易提供的众多服务,如事务管理,消息服务等
    • 容器提供单例模式支持
    • 容器提供了AOP技术,利用它很容易实现如权限拦截,运行期监控等功能
    • 容器提供了众多的辅助类,能加快应用的开发
    • spring对于主流的应用框架提供了集成支持,如hibernate,JPA,Struts等
    • spring属于低侵入式设计,代码的污染极低
    • 独立于各种应用服务器
    • spring的DI机制降低了业务对象替换的复杂性
    • Spring的高度开放性,并不强制应用完全依赖于Spring,开发者可以自由选择spring的部分或全部
  • 缺点:
    • 使用到了大量反射机制。反射机制非常占内存,

4. 企业开发的项目: 技术说明(1.5)

5. 面试总结(3,4)

以上是关于面試就业题库-04的主要内容,如果未能解决你的问题,请参考以下文章

面試題之web

Java面試題(实用性高)

幼稚園面試必考三十題

就业信息追踪|基于Springboot+Vue开发实现就业信息追踪系统

就业信息追踪|基于Springboot+Vue开发实现就业信息追踪系统

嵌入式题库最全的,去公司面试都会出现