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的拦截器有关系有什么区别?

过滤器是web是三大组件之一,基于web开发环境(web项目).
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原理

SpringAOP: 本质就是对业务类中的方法进行增强.
动态代理设计模式: 本质就是对类中的方法进行增强
- 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的部分或全部
缺点:
- 使用到了大量反射机制。反射机制非常占内存，