Java面试宝典书籍-框架

最新推荐文章于 2021-07-07 00:37:38 发布

晋升之道

最新推荐文章于 2021-07-07 00:37:38 发布

阅读量600

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_28400629/article/details/99173058

版权

Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

web框架 (注：知识都来源于Java面试宝典书籍，此处只为学习)

一、Springmvc

1. springmvc的工作原理

a. 用户向服务器发送请求，请求被springmvc前端控制器DispatchServlet捕获
b. DispatchServlet对请求URL进行解析，得到请求资源标识符(URL)，然后根据URL调用HandlerMapping将请求映射到处理器HandlerExcutionChain
c. DispatchServlet根据获得的Handler选择一个合适的HandlerAdapter适配器处理
d. Handler 对数据处理完成以后将返回一个 ModelAndView（）对象给 DisPatchServlet
e. Handler 返回的 ModelAndView()只是一个逻辑视图并不是一个正式的视图，DispatcherSevlet 通过ViewResolver 视图解析器将逻辑视图转化为真正的视图 View
f. DispatcherServle 通过 model 解析出 ModelAndView()中的参数进行解析最终展现出完整的 view 并返回给客户

2. springmvc常用的注解有哪些

@requestMapping 用于请求 url 映射
@RequestBody 注解实现接收 http 请求的 json 数据，将 json 数据转换为 java 对象
@ResponseBody 注解实现将 controller 方法返回对象转化为 json 响应给客户

3. 如何开启注解处理器和适配器

<mvc:annotation-driver/>

4. 如何解决get和post乱码问题

post乱码：在web.xml里配置一个characterEncodingFilter过滤器。设置为utf-8

<filter>
    <filter-name>encoding-filter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>encoding-filter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

get乱码：

修改 tomcat 配置文件添加编码与工程编码一致
另外一种方法对参数进行重新编码

String userName = new String(Request.getParameter("userName").getBytes("ISO8859-1"),"UTF-8");

5. springmvc实现细节

1) mvc：model、view、controller

DispatcherServlet：拦截请求发送给 Spring MVC 控制器

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <!-- 拦截所有的请求 -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

HandlerMapping：处理映射器

<bean id="simpleUrlHandlerMapping"
      class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <props>
            <!-- /hello 路径的请求交给 id 为 helloController 的控制器处理-->
            <prop key="/hello">helloController</prop>
        </props>
    </property>
</bean>
<bean id="helloController" class="controller.HelloController"></bean>


----------------------------------------
// 因此使用注解配置极大地简化了代码

@RequestMapping(value="/hello")

控制器：后端代码

public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
    // 处理逻辑
    ....
    // 返回给DipatcherServlet
    return mav;
}

视图解析器--相关配置

<bean id="viewResolver"
      class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/page/" />
    <property name="suffix" value=".jsp" />
</bean>

3) springmvc的web.xml和springmvc.xml配置

web.xml

<!-- Spring MVC配置 -->
<!-- ====================================== -->
<servlet>
    <servlet-name>spring</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 可以自定义servlet.xml配置文件的位置和名称，默认为WEB-INF目录下，名称为[<servlet-name>]-servlet.xml，如spring-servlet.xml
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring-servlet.xml</param-value>&nbsp; 默认
    </init-param>
    -->
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>spring</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"     
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"     
        xmlns:context="http://www.springframework.org/schema/context"     
   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd   
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd   
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd   
       http://www.springframework.org/schema/context <a href="http://www.springframework.org/schema/context/spring-context-3.0.xsd">http://www.springframework.org/schema/context/spring-context-3.0.xsd</a>">

    <!-- 启用spring mvc 注解 -->
    <mvc:annotation-driver/>

    <!-- 设置使用注解的类所在的jar包 -->
    <context:component-scan base-package="controller"/>

    <!-- 完成请求和注解POJO的映射 -->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
　　
    <!-- 对转向页面的路径解析。prefix：前缀， suffix：后缀 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/page/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <!-- 静态资源映射 -->
    <mvc:resources mapping="/resources/**" location="/resources/" />
    <mvc:resources mapping="/src/**" location="/src/" />
    <mvc:resources mapping="/images/**" location="/images"/>
    <mvc:default-servlet-handler />

    <!-- 多文件上传配置 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"/>

</beans>

二、Spring

1. spring理解

Spring是一个IOC和AOP容器框架

1) 控制反转(IOC)，传统的 java 开发模式中，当需要一个对象时，我们会自己使用 new 或者 getInstance 等直接或者间接调用构造方法创建一个对象。而在 spring 开发模式中，spring 容器使用了工厂模式为我们创建了所需要的对象，不需要我们自己创建了，直接调用 spring 提供的对象就可以了，这是控制反转的思想。

2) 依赖注入(DI)，spring 使用 javaBean 对象的 set 方法或者带参数的构造方法为我们在创建所需对象时将其属性自动设置所需要的值的过程，就是依赖注入的思想

3) 面向切面编程（AOP），在面向对象编程（oop）思想中，我们将事物纵向抽成一个个的对象。而在面向切面编程中，我们将一个个的对象某些类似的方面横向抽成一个切面，对这个切面进行一些如权限控制、事物管理，记录日志等公用操作处理的过程就是面向切面编程的思想。AOP 底层是动态代理，如果是接口采用 JDK 动态代理，如果是类采用CGLIB 方式实现动态代理

2. Spring中的设计模式

单例模式：如果是接口采用 JDK 动态代理，如果是类采用CGLIB 方式实现动态代理 spring配置的默认是单例模式
模板模式：用来解决代码重复的问题--RestTemplate、JmsTemplate、JpaTemplate
前端控制器模式——spring 提供了前端控制器 DispatherServlet 来对请求进行分发
视图帮助（view helper）——spring 提供了一系列的 JSP 标签，高效宏来帮助将分散的代码整合在视图中
依赖注入——贯穿于 BeanFactory/ApplacationContext 接口的核心理念
工厂模式——在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用同一个接口来指向新创建的对象。Spring 中使用 beanFactory 来创建对象的实例

1) 单例模式和多例模式

https://blog.csdn.net/zt13258579889/article/details/79558922 作者：云雨寒冰

singleton：对象在整个系统中只有一份，所有的请求都用一个对象来处理，如service和dao层的对象一般是单例的

prototype：对象在整个系统中可以有多个实例，每个请求用一个新的对象来处理，如action。为什么使用多例：防止并发问题；即一个请求改变了对象的状态，此时对象又处理另一个请求，而之前请求对对象的状态改变导致了对象对另一个请求做了错误的处理

实体类

package a_helloword.entity;
 
public class User {
    private String id;
    private String name;
    private String password;
 
 
    public void destroy(){
        System.out.println("我销毁了");
    }
    public void init(){
        //this.name="给不";
        System.out.println("已经调用了初始化方法");
    }
    public String getId() {
        return id;
    }
 
    public void setId(String id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password1) {
        this.password = password1;
    }
 
}

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
							http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
							http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
							http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd ">
    <!--把User类放到容器中-->
    <!--
        bean：该元素需要Spring来管理，将User对象交给Spring管理
        name: 给被管理的对象取一个名字，为了更方便的根据名字获得对象，用name的时候不能用特殊字符
        id：和name的作用是一样的，使用name的话不能使用特殊字符。尽量使用name，
        class：完整类名
        scope: singleton：单例,prototype ：多例
        init-method:创建完成对象后，立即执行的方法
        destroy-method：对象消亡的时候调用，Spring 容器关闭时会销毁所有的对象
    -->
    <bean  id="user"
           name="user"
           class="a_helloword.entity.User"
           scope="singleton"
           init-method="init"
           destroy-method="destroy"
    ></bean>
 
 
</beans>

测试类

package a_helloword.test;
 
import a_helloword.entity.User;
 
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Demo {
    @Test
    public void fun(){
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("a_helloword/applicationContext.xml");
        User user = (User) ac.getBean("user");
        User user1 = (User) ac.getBean("user");
        System.out.println(user);


        // 单例模式运行结果

        // 已经调用了初始化方法
        // a_helloword.entity.User@51c8530f
        // a_helloword.entity.User@51c8530f
        
        // 多例模式
        
        // 已经调用了初始化方法
        // 已经调用了初始化方法
        // a_helloword.entity.User@5891e32e
        // a_helloword.entity.User@cb0ed20
        
    }   
}

2) 模板模式-JDBCTemplate：封装了(获得数据库连接，处理事务，处理异常，关闭资源等通用方法)

https://www.cnblogs.com/caoyc/p/5630622.html 作者：JustDo

JDBCTemplate：

execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句
update方法用于执行新增、修改、删除等语句
batchUpdate方法用于执行批处理相关语句
query方法及queryForXXX方法：用于执行查询相关语句
call方法：用于执行存储过程、函数相关语句

jdbc.properties

mysql数据库

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

spring.xml

<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="user" value="${jdbc.user}"></property>
    <property name="password" value="${jdbc.password}"></property>
    <property name="driverClass" value="${jdbc.driverClass}"></property>
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>

测试

//启动IoC容器
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//获取IoC容器中JdbcTemplate实例
JdbcTemplate jdbcTemplate=(JdbcTemplate) ctx.getBean("jdbcTemplate");
String sql="insert into user (name,deptid) values (?,?)";
int count= jdbcTemplate.update(sql, new Object[]{"caoyc",3});
System.out.println(count);

3. Spring常用的注解

<context:annotation-confg/>
@Required:该注解应用于设值方法
@Autowired：该注解应用于有值设值方法、非设值方法、构造方法和变量
@Qualifier：该注解和@Autowired 搭配使用，用于消除特定 bean 自动装配的歧义

4. 简单介绍spring bean的生命周期

1) bean定义：在配置文件<bean></bean>

2) 初始化

在配置文件中通过指定 init-method 属性来完成
实现 org.springframwork.beans.factory.InitializingBean 接口

3) 调用

4) 销毁

使用配置文件指定的 destroy-method 属性
实现 org.springframwork.bean.factory.DisposeableBean 接口

5. spring结构图

6. spring作用

Spring 能帮我们根据配置文件创建及组装对象之间的依赖关系
Spring 面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制
Spring 能非常简单的帮我们管理数据库事务
Spring 还能与第三方数据库访问框架（如 Hibernate、JPA）无缝集成，而且自己也提供了一套 JDBC访问模板，来方便数据库访问
Spring 还能与第三方 Web（如 Struts、JSF）框架无缝集成，而且自己也提供了一套 Spring MVC框架，来方便 web 层搭建
Spring 能方便的与 Java EE（如 Java Mail、任务调度）整合，与更多技术整合（比如缓存框架）

7. 描述spring的事物

https://blog.csdn.net/jiadajing267/article/details/81056057 作者：mandy@i

声明式事务管理的定义：用spring配置文件中声明式事务来代替代码式事务

配置

	<!-- 1. 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 2. 配置事务属性 -->
	<!--<tx:advice>元素声明事务通知-->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 根据方法名指定事务的属性 -->
			<tx:method name="*"/>
			<!--propagation配置事务传播行为-->
			<tx:method name="purchase" propagation="REQUIRES_NEW"/>
			<!--isolation配置事务的隔离级别-->
			<tx:method name="update*" isolation="SERIALIZABLE"/>
			<!--rollback-for配置事务遇到异常必须回滚，no-rollback-for配置事务遇到异常必须不能回滚-->
			<tx:method name="add*" rollback-for="java.io.IOException" no-rollback-for="com.dmsd.spring.tx.BookStockException"/>
			<!--read-only配置事务只读属性-->
			<tx:method name="find*" read-only="true"/>
			<!--timeout配置事务的超时属性-->
			<tx:method name="get*" timeout="3"/>
		</tx:attributes>
	</tx:advice>
	
	<!-- 3. 配置事务切入点, 以及把事务切入点和事务属性关联起来 -->
	<aop:config>
		<aop:pointcut expression="execution(* com.atguigu.spring.tx.xml.service.*.*(..))" 
			id="txPointCut"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>	
	</aop:config>

注解

        <!-- 配置事务管理器 -->
	<bean id="transactionManager" 
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 启用事务注解 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>


    <!-- 在方法上添加注解 -->
    <!-- @Transactional -->

8. BeanFactory常用的实现类有哪些

DefaultListBeanFactory
XmlBeanFactory
ApplicationContext

9. Spring JDBC、Spring DAO、Spring ORM

Spring-JDBC：提供了 Jdbc 模板类，它移除了连接代码以帮你专注于 SQL 查询和相关参数
Spring-DAO：并非 Spring 的一个模块，它实际上是指示你写 DAO 操作、写好 DAO 操作的一些规范。因此，对于访问你的数据它既没有提供接口也没有提供实现更没有提供模板
Spring-ORM：是一个囊括了很多持久层技术(JPA，JDO，Hibernate，iBatis)的总括模块

10. spring web模块

https://www.cnblogs.com/davidwang456/p/4443942.html 作者：一天不进步，就是退步

11. spring配置文件有什么作用

Spring 配置文件是个 XML 文件，这个文件包含了类信息，描述了如何配置它们，以及如何相互调用

https://www.cnblogs.com/Sunnor/p/5688967.html 作者：Sunor

12. IOC优点

IOC 控制反转：Spring IOC 负责创建对象，管理对象。通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期

IOC 或依赖注入把应用的代码量降到最低。它使应用容易测试，单元测试不再需要单例和 JNDI 查找机制。最小的代价和最小的侵入性使松散耦合得以实现。IOC 容器支持加载服务时的饿汉式初始化和懒加载

13. ApplicationContext的实现类有哪些

FileSystemXmlApplicationContext：此容器从一个 XML 文件中加载 beans 的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数
ClassPathXmlApplicationContext：此容器也从一个 XML 文件中加载 beans 的定义，这里，你需要正确设置classpath 因为这个容器将在 classpath 里找 bean 配置
WebXmlApplicationContext：此容器加载一个 XML 文件，此文件定义了一个 WEB 应用的所有 bean

14. BeanFactory与ApplicationContext

BeanFactory：基础类型的 IOC 容器，提供完成的 IOC 服务支持。如果没有特殊指定，默认采用延迟初始化策略。相对来说，容器启动初期速度较快，所需资源有限
ApplicationContext：ApplicationContext 是在 BeanFactory 的基础上构建，是相对比较高级的容器实现，除了 BeanFactory 的所有支持外，ApplicationContext 还提供了事件发布、国际化支持等功能。ApplicationContext 管理的对象，在容器启动后默认全部初始化并且绑定完成

15. 什么是Spring的依赖注入

通常某个类依赖某个类时，使用new的方法调用某个类的实例，但是容易发生并发问题；spring提出依赖注入的思想，则依赖类不用由程序员实例化。通俗的理解是：平常我们 new 一个实例，这个实例的控制权是我们程序员，而控制反转是指 new 实例工作不由我们程序员来做而是交给 spring 容器来做

16. spring注入方式

set注入
构造器注入
静态工厂的方法注入
实例工厂的方法注入

https://www.cnblogs.com/doudou618/p/4325995.html 作者：骚年轻狂

17. 什么是spring beans

1) Spring beans 是那些形成 Spring 应用的主干的 java 对象。它们被 Spring IOC 容器初始化，装配，和管理。这些 beans 通过容器中配置的元数据创建。比如，以 XML 文件中<bean/> 的形式定义。Spring 框架定义的 beans 都是单例 beans

2) 定义：一个 Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建一个 bean，它的生命周期详情及它的依赖

3) 定义类的作用域：scope

18. 内部bean

内部bean：当一个大对象包含一个小对象

<!--InnerBean-->
<bean id="outer" class="com.lyc.cn.v2.day01.inner.Outer">
	<property name="name" value="我是一个外部bean"></property>
	<property name="age" value="20"></property>
	<!--注意这里是property属性，不是beanName-->
	<property name="inner">
		<bean class="com.lyc.cn.v2.day01.inner.Inner">
			<property name="name" value="我是一个内部bean"></property>
			<property name="age" value="10"></property>
		</bean>
	</property>
</bean>

19. spring中注入一个java集合

list
set
map
props

20. 自动装配

定义：无须在spring配置文件描述javabean之间的依赖关系，IOC会自动建立javabean之间的关联关系

装配方式：

no：默认的方式是不进行自动装配，通过显式设置 ref 属性来进行装配
byName：通过参数名自动装配，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byname，之后容器试图匹配、装配和该 bean 的属性具有相同名字的 bean
byType：通过参数类型自动装配，通过参数名自动装配，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byname，之后容器试图匹配、装配和该 bean 的属性具有相同名字的 bean
constructor：这个方式类似于 byType，但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常
autodetect：首先尝试使用 constructor 来自动装配，如果无法工作，则使用 byType 方式 --spring3.0之后不在支持

21. spring通知

before
after
after-returning
after-throwing
around

三、Mybatis

1. Mybatis

1) 定义：MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架

2) 作用：

Mybatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集
MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录

2. Mybatis中#和$的区别

#相当于对数据加上双引号--order by #user_id# --> order by "111" #方式能够很大程度防止 sql 注入
$相当于直接显示数据--order by $user_id$ --> order by 111 $方式无法防止 Sql 注入 $方式一般用于传入数据库对象，例如传入表名

3. Mybatis的编程步骤

创建 SqlSessionFactory
通过 SqlSessionFactory 创建 SqlSession
通过 sqlsession 执行数据库操作
调用 session.commit()提交事务
调用 session.close()关闭会话

3. JDBC不足之处以及Mybatis如何解决这些问题

数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。解决：在 SqlMapConfig.xml 中配置数据连接池，使用连接池管理数据库链接
Sql 语句写在代码中造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java 代码。解决：将 Sql 语句配置在 XXXXmapper.xml 文件中与 java 代码分离
向 sql 语句传参数麻烦，因为 sql 语句的 where 条件不一定，可能多也可能少，占位符需要和参数一一对应。解决：Mybatis 自动将 java 对象映射至 sql 语句
对结果集解析麻烦，sql 变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成 pojo 对象解析比较方便。解决：Mybatis 自动将 sql 执行结果映射至 java 对象

4. 使用Mybatis的mapper接口调用时有哪些要求

Mapper 接口方法名和 mapper.xml 中定义的每个 sql 的 id 相同
Mapper 接口方法的输入参数类型和 mapper.xml 中定义的每个 sql 的 parameterType 的类型相同
Mapper 接口方法的输出参数类型和 mapper.xml 中定义的每个 sql 的 resultType 的类型相同
Mapper.xml 文件中的 namespace 即是 mapper 接口的类路径

5. Mybatis中一级缓存与二级缓存

一级缓存：其存储作用域为session，当session flush或close之后，该session的所有的cache就清空
二级缓存：其存储作用域为Mapper，
缓存数据更新机制，当某一个作用域(一级缓存 Session/二级缓存 Namespaces)的进行了 C/U/D 操作后，
默认该作用域下所有 select 中的缓存将被 clear

6. Mybatis在insert插入操作时返回主键ID

<insert id="insert" parameterType="com.test.User" keyProperty="userId" userGeneratedKeys="true">

8. Mybatis-generator(逆向工程)

https://blog.csdn.net/qq_28400629/article/details/98474152

7. SSM：spring、springMVC、Mybatis融合

https://blog.csdn.net/yanmiao0715/article/details/82502694 作者：Roobtyan

https://blog.csdn.net/yanmiao0715/article/details/82562268 (重点)

(来源于网络)

四、shiro

1. shiro概念图

shiro作用：认证、授权、加密、会话管理、与 Web 集成、缓存等

三大组件：

subject：当前操作用户，代表了当前用户的安全操作
securityManager：它是 Shiro 框架的核心，典型的 Facade 模式，Shiro 通过 SecurityManager 来管理内部组件实例，并通过它来提供安全管理的各种服务
realms：Realm 充当了 Shiro 与应用安全数据间的“桥梁”或者“连接器”。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro 会从应用配置的 Realm 中查找用户及其权限信息

2. Shiro主要的四个组件

SecurityManager：Shiro 通过它对外提供安全管理的各种服务
Authenticator：涉及用户名和密码，这个组件负责收集principals(身份)和credentials(证明)，并将他们提交到应用系统，如果提交的 credentials 跟应用系统中提供的 credentials 吻合，就能够继续访问，否则需要重新提交 principals 和 credentials，或者直接终止访问。
Authorizer：身份份验证通过后，由这个组件对登录人员进行访问控制的筛查，比如“who can do what”，或者“who can do which actions”。 Shiro 采用“基于 Realm”的方法，即用户（又称 Subject）、用户组、角色和permission 的聚合体
session manager：这个组件保证了异构客户端的访问，配置简单。它是基于 POJO/J2SE 的，不跟任何的客户端或者协议绑定

3. shiro运行原理

Application Code：应用程序代码，就是我们自己的编码，如果在程序中需要进行权限控制，需要调用Subject 的 API
Subject：主体，代表的了当前用户。所有的 Subject 都绑定到 SecurityManager，与 Subject 的所有交互都会委托给 SecurityManager,可以将 Subject 当成一个门面，而真正执行者是 SecurityManager
SecurityManage:安全管理器，所有与安全有关的操作都会与 SecurityManager 交互，并且它管理所有的 Subject
Realm:域 shiro 是从 Realm 来获取安全数据（用户，角色，权限）。就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把 Realm 看成 DataSource，即安全数据源

4. shiro的四种权限控制方式

url 级别权限控制
方法注解权限控制
代码级别权限控制
页面标签权限控制

5. 授权实现的流程

1) 粗颗粒和细颗粒

粗颗粒：对资源类型的管理称为粗颗粒度权限控制，即只控制到菜单、按钮、方法，粗粒度的例子比如：用户具有用
户管理的权限，具有导出订单明细的权限针对 url 链接的控制
细颗粒：对资源实例的控制称为细颗粒度权限管理，即控制到数据级别的权限，比如：用户只允许修改本部门的员工信息，用户只允许导出自己创建的订单明细针对数据级别的控制

2) 粗颗粒和细颗粒如何授权