面试中的Spring知识

Spirng

设计层面框架，解决业务逻辑层与其他层面的松耦问题。

Spring IOC控制反转：一种编程思想，借助容器来管理对象之间的依赖关系。
Spring DI依赖注入：DI是实现IOC的一种手段，其内部是通过Java的反射机制来实现的。
Spring AOP:声明式事务（切点、方法拦截器）。是一种OOP的延伸，用于给不存在继承关系的对象之间引用一个公共行为。

Spring Bean的生命周期
Bean的生命周期（10个）：
Bean建立、Setter、BeanName、BeanFactory、加工构造前、参数注入后、构造、加工构造后、默认销毁、自定义销毁

SpringMVC

SpringMVC怎么处理请求的 （Handler:处理器 、resolver解析器、Adapter适配器）
Model模型：存取数据
View视图：展示数据
Controller控制器：与用户进行交互

DispatcherServlet 前端控制器：接收用户请求
HandlerAdapter 处理器适配器：选择合适的处理器，并且调用相应功能处理方法
ViewResolver 视图解析器

用户发送请求和返回响应的流程：
1.发送请求 至DispatcherServlet
2.映射处理器 获取处理器映射至 DispatcherServet
3.HandlerAdapter进行处理器适配
4.调用处理器相应功能处理方法 （获得 View 和model 至DispatcherServlet ） 这里涉及Controller
5.ViewResolver 接收View 进行视图解析
6.Model加入到View 中进行视图渲染
7.DispatcherServlet返回响应

Spring Security

Spring Security是什么？
Spring Security是一个强大且高度可定制的身份验证和访问控制架构。

SpringSecurity的两个操作：
认证：确认用户可以访问当前系统。
授权：确认用户可以执行操作的权限。

SpringSecurity的组件
核心模块：包含核心的验证和访问控制类以及接口、远程支持和基本的配置的API。
远程调用：提供与Spring Remoting的集合。
Web网页：包含网站安全的基础代码，包含Spring Security页面验证服务和基于URL的访问控制。
配置：如果使用Spring Security XML命令空间进行配置，需要使用该模块。
LDAP:LDAP验证和配置代码
ACL访问控制表：用于在应用程序中对特定域对象实例应用安全性。
CAS：用于CAS的SSO服务器使用Spring Security网页验证
OpenID:使用外部的OpenID服务器验证用户
Test:支持Spring Security的测试

注：
Spring Remoting :Spring提供远程调用的模块；
LDAP：是轻量级的目录访问协议
CAS:中央认证服务
OpenID 是一个以用户为中心的数字身份识别框架

RBAC
RBAC 是基于角色的访问控制（Role-Based Access Control ）在 RBAC 中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。这样管理都是层级相互依赖的，权限赋予给角色，而把角色又赋予用户，这样的权限设计很清楚，管理起来很方便。

权限数据库设计：
总共由5张表组成，用户表、角色表、资源表、用户角色表和角色资源表。一个用户可以拥有多个角色，一个角色拥有多个资源。
拦截器控制权限：（URL权限映射文件 .properties）
界面通过url进行请求，由拦截器进行拦截，根据用户的信息，去数据库中查询此用户是否具有本次请求了url权限，如果有就通过请求，让他访问资源，如果没有就返回，提示用户不具有该资源的反问权限.

Spring中设计的设计模式

单例模式：
使用场景：资源共享的情况
描述：单例模式自行实例化且实例化一次 构造函数必须是私有的
类别：懒汉单例模式和饥汉单例模式
懒汉单例模式：在调用资源时，如果没有进行实例化的话，就进行一次实例化。为了避免重复线程干扰要标记临界区或者借助锁机制。
饥汉单例模式：在没有调用时就已经自行实例化了。
注：对象属性和get方法都要用static标记

public class SingleA
{
       
       public static SingleA singleA=null;
       private SingleA()
       {
             System.out.println("这是懒汉单例模式");
       }
       
       
       public static synchronized SingleA getSingleA() {
             
             
             if(singleA==null)
             {
             singleA=new SingleA();
             
             }
             
             return singleA;
       }
       
}

public class SingleB
{
       public static SingleB singleB=new SingleB();
       
       private SingleB()
       {
             System.out.println("这是饥汉单例模式");
       }
       public static SingleB getSingleB() {
             return singleB;
       }
       
       
}

//测试类
import org.junit.Test;
public class 单例模式 {
       @Test
       public void test()
       {
             SingleA.getSingleA();
             SingleB.getSingleB();
             
       }
       
       
       
}

观察者模式
描述：定义了一种一对多的依赖关系让多喝观察者同时监听某一个主体对象。这个主体对象当状态发生改变时，会通知所有观察者对象，使他们能够自动更新自己。
一个观察者，多个通知者。
应用场景：Serlvet基于此思想

控制反转：把改变自己权限给别人。

public interface State {
         void doAction(Soldier soldier);
}

public class StartState implements State {
       @Override
       public void doAction(Soldier soldier) {
             // TODO Auto-generated method stub
             System.out.println("士兵开始攻击");
             soldier.setState(this);
       }
       @Override
       public String toString() {
             return "士兵正在攻击";
       }
       
}

public class StopState implements State{
       @Override
       public void doAction(Soldier soldier) {
             // TODO Auto-generated method stub
             System.out.println("士兵停止攻击");
             soldier.setState(this);
       }
       @Override
       public String toString() {
             return "士兵已停止攻击";
       }
}

public class Soldier {
       private State state;
       public State getState() {
             return state;
       }
       public void setState(State state) {
             this.state = state;
       }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Observer {
       
       private List <Soldier>list=new ArrayList<>();
       
       private State state;
       
       //进入观察
       public void add(Soldier soldier)
       {
             list.add(soldier);
       }
    //离开观察
       public void  remove(Soldier soldier)
       {
             list.remove(soldier);
       }
       //设置情报
       public State getState() {
             return state;
       }
       //获取情报
       public void setState(State state) {
             this.state = state;
       }
  
       
       //通知获取情报
       public void inform()
       {
             for(Soldier s :list)
             {
                    
                    if(this.state!=null)
                    {
                    this.state.doAction(s);
                    }else
                    {
                           System.out.println("请先设置状态");
                    }
             }
             
       }
       
}

public class testDemo {
       public static void main(String[] args) {
             
             Soldier a =new Soldier();
             Soldier b=new Soldier();
             
             Observer observer=new Observer();
             
             //雇佣观察者
             observer.add(a);
             observer.add(b);
             
             //发出进攻指令
             observer.setState(new StartState());
             observer.inform();//进行通知
             System.out.println(a.getState());
             System.out.println(b.getState());
             
             
             //发出进攻指令
             observer.setState(new StopState());
             observer.inform();//进行通知
             System.out.println(a.getState());
             System.out.println(b.getState());
       }
}