1.Spring IOC

IOC与DI的理解

一：IOC控制反转(宏观方面-设计理念)
1、IOC控制反转全称Inverse of Control，是一种设计理念，是宏观方面的
2、由第三方来管理和控制对象
3、IOC根本目的：降低对象之间直接耦合

二：DI依赖注入（是IOC理念的技术实现）
1、IOC是一种设计理念，是现代程序设计遵循的标准，是宏观目标
2、DI是一种具体技术实现，是微观实现，是对宏观的IOC理念的一种技术上诠释
3、DI在Spring中利用反射技术和工厂模式实现对象注入

&&原始的创建对象IDAO dao = new UserDAO();
&&DI(IOC)创建对象//在运行时applicationContext对象创建userDAO类IDAO dao = (DAO)applicationContext.getBean("userDAO");<bean id="userDAO" class="com.imooc.dao.UserDAO"/><bean id="userDAO" class="com.imooc.dao.UserExtDAO"/>

Spring Bean实例化对象的三种形式

1、基于构造方法实例化对象
2、基于静态工厂实例对象
3、基于工厂实例方法实例化对象
…
一：基于构造方法实例化对象
1、Apple实体类

public class Apple {public String title;public String color;public String origin;public Float price; // .... getter和setter、无参构造方法、有参构造方法
}

2、applicationContext.xml配置Bean指向Apple，通过bean标签对象实例化

    <!--构造函数实例化-->**<!--使用无参构造方法实例化对象-->**<bean id="apple1" class="com.imooc.spring.ioc.entity.Apple"></bean>**<!--使用带参构造方法实例化对象-->**<bean id="apple2" class="com.imooc.spring.ioc.entity.Apple"><constructor-arg name="title" value="红富士"/><constructor-arg name="color" value="红色"/><constructor-arg name="origin" value="欧洲"/><constructor-arg name="price" value="19.8"/></bean>

3、创建IOC容器

//1.创建context对象，而其对象本身就带有Spring IOC容器，classpath当前类路径下
ClassPathXmlApplicationContext context = new  ClassPathXmlApplicationContext("classpath:applicationContext.xml");
//2.从IoC容器中提取beadId对象
Apple apple3 = context.getBean("apple3", Apple.class);
System.out.println(apple3.getTitle());

二：基于静态工厂实例对象
1、AppleStaticFactory类

/*** 静态工厂通过静态方法创建对象，
隐藏创建对象的细节*/
public class AppleStaticFactory {/*** spring如何通过AppleStaticFactory
静态工厂调用createSweetApple方法*/public static Apple createSweetApple(){Apple apple = new Apple();apple.setTitle("红富士");apple.setOrigin("欧洲");apple.setColor("红色");return apple;}
}

2、applicationContext.xml配置Bean指向AppleStaticFactory，通过bean标签对象实例化

<!--利用静态工厂实例化对象-->
<bean id="apple4" class="com.imooc.spring.ioc.factory.AppleStaticFactory" factory-method="createSweetApple"/>

3、创建IOC容器

//1.创建context对象，而其对象本身就带有Spring IOC容器，classpath当前类路径下
ClassPathXmlApplicationContext context = new  ClassPathXmlApplicationContext("classpath:applicationContext.xml");
//2.从IoC容器中提取beadId对象
Apple apple3 = context.getBean("apple3", Apple.class);
System.out.println(apple3.getTitle());

三：基于工厂实例方法实例化对象
1、AppleFactoryInstance 工厂实例

/*** 工厂实例方法创建对象是指IOC容器对工厂类进行实例化* 并调用对应的实例方法创建对象的过程*/
public class AppleFactoryInstance {/*** createSweetApple 是属于AppleFactoryInstance工厂对象的，* 而不是属于工厂类的* @return*/public Apple createSweetApple(){Apple apple = new Apple();apple.setTitle("红富士1");apple.setOrigin("欧洲");apple.setColor("红色");return apple;}
}

2、applicationContext.xml配置Bean指向AppleFactoryInstance，通过bean标签对象实例化

<!--利用工厂实例化对象-->
<bean id="factoryInstance" class="com.imooc.spring.ioc.factory.AppleFactoryInstance"/>
<bean id="apple5" factory-bean="factoryInstance" factory-method="createSweetApple"/>

3、创建IOC容器

//1.创建context对象，而其对象本身就带有Spring IOC容器，classpath当前类路径下
ClassPathXmlApplicationContext context = new  ClassPathXmlApplicationContext("classpath:applicationContext.xml");
//2.从IoC容器中提取beadId对象
Apple apple3 = context.getBean("apple3", Apple.class);
System.out.println(apple3.getTitle());

谈谈Spring Bean的生命周期和作用域？

Spring Bean 生命周期比较复杂，可以分为创建和销毁两个过程。
一：首先，创建 Bean 会经过一系列的步骤，主要包括：
1、实例化 Bean 对象。
2、设置 Bean 属性。
3、如果我们通过各种 Aware 接口声明了依赖关系，则会注入 Bean 对容器基础设施层面的依赖。具体包括 BeanNameAware、BeanFactoryAware 和 ApplicationContextAware，分别会注入 Bean ID、Bean Factory 或者 ApplicationContext。
4、调用 BeanPostProcessor 的前置初始化方法 postProcessBeforeInitialization。
5、如果实现了 InitializingBean 接口，则会调用 afterPropertiesSet 方法。
6、调用 Bean 自身定义的 init 方法。调用 BeanPostProcessor 的后置初始化方法 postProcessAfterInitialization。
7、创建过程完毕。
如下图：

二：Spring Bean 的销毁过程会依次调用 DisposableBean 的 destroy 方法和 Bean 自身定制的 destroy 方法。
Spring Bean 有五个作用域，其中最基础的有下面两种：
1、Singleton，这是 Spring 的默认作用域，也就是为每个 IOC 容器创建唯一的一个 Bean 实例。
2、Prototype，针对每个 getBean 请求，容器都会单独创建一个 Bean 实例。
从 Bean 的特点来看，Prototype 适合有状态的 Bean，而 Singleton 则更适合无状态的情况。
另外，使用 Prototype 作用域需要经过仔细思考，毕竟频繁创建和销毁 Bean 是有明显开销的。

如果是 Web 容器，则支持另外三种作用域：
1、Request，为每个 HTTP 请求创建单独的 Bean 实例。
2、Session，很显然 Bean 实例的作用域是 Session 范围。
3、GlobalSession，用于 Portlet 容器，因为每个 Portlet 有单独的 Session，GlobalSession 提供一个全局性的 HTTP Session。

知识扩展
一：Spring 的基础机制
1、控制反转（Inversion of Control），或者也叫依赖注入（Dependency Injection），广泛应用于 Spring 框架之中，可以有效地改善了模块之间的紧耦合问题。
从 Bean 创建过程可以看到，它的依赖关系都是由容器负责注入，具体实现方式包括带参数的构造函数、setter 方法或者AutoWired方式实现。
2、AOP这种切面编程机制，Spring 框架中的事务、安全、日志等功能都依赖于 AOP 技术。
Spring AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。
AOP的做法是将通用、与业务无关的功能抽象封装为 切面类。
切面可配置在目标方法的执行前、后运行，真正做到即插即用。
AOP的最终目的：在不修改源码的情况下对程序行为进行扩展。

Spring的IOC四种注入方式

一：setter注入

二：构造器注入
即通过构造函数完成依赖关系的设定。

三：注解注入
即通过注解方式完成依赖关系的设定
@Resource先会按照名称到spring容器中查找，如果查找不到，就回退按照类型匹配，如果再没有匹配到，就会抛出异常。如果在开发的时候，建议大家都是用@Resource(name=”userDao”)，此时只能够按照名称匹配

四：Java Config注入

2.Spring IOC常见面试问题

请说明Scope属性的作用与取值范围

一：bean scope属性
1、bean scope属性用于决定对象何时被创建和作用范围
2、bean scope配置将影响容器内对象的数量【被多个对象引用】
3、bean scope默认值singleton（单利），指全局共享同一个对象实例；prototype为多例模式，会创建多个对象，每一次调用getBean创建新的对象。

<!--UserService默认为单利，在IOC容器初始化的时候被创建-->
applicationContext.xml：
<bean id="userService" class="com.imooc.spring.ioc.service.UserService" scope="prototype"><!--ref关联userDao，name是dao属性名--><property name="userDao" ref="userDao"/>
</bean>创建IOC容器：
//创建对象，包含了IOC容器
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
System.out.println("IOC容器已初始化");
//获取bean
context.getBean("userDao", UserDao.class);
context.getBean("userDao", UserDao.class);

二：scope取值范围

单利模式(singleton)：不写scope默认为单利，典型特点-对于当前的bean来说在IOC容器初始化的过程中被创建
多例模式(prototype)：创建对象的时机并不是在IOC容器初始化的时候被创建，而是在获取bean(getBean)或对象注入的时候才会被创建，如 context.getBean(“userDao”, UserDao.class);每一次调用getBean创建新的对象

请说明lazy-init属性的作用

lazy-init：延迟初始化，也称之为懒加载。
lazy-init=“true”：默认为false，不需要延迟初始化；设置为true的时候，则代表需要用到bean的时候才会进行实例化的操作；但是scope设置为prototype多利模式下，lazy-init会失效。

@Autowired与@Resource两类自动装配注解有什么区别

@Autowired：第三方提供的包；机制：Autowired只能够按照类型在IOC容器中进行匹配。
@Resource：Java官方提供的包；
机制：Resource可以设name属性设置bean的id，对应name属性Autowired是没有的；
Resource的匹配规则：如果设置了name这个属性则按照bean id进行精准匹配，如果没有设置name属性优先将属性名字在IOC容器中进行查找，没有的话再按照类型进行查找。

3.Spring AOP

Spring AOP介绍

一：AOP介绍
1、Spring AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。
2、AOP的做法是将通用、与业务无关的功能抽象封装为 切面类
3、切面可配置在目标方法的执行前、后运行，真正做到即插即用
（大白话：就是使用AOP-面向切面编程在目标方法的执行前或者执行后，对原有的功能加入其它的功能）
AOP的最终目的：在不修改源码的情况下对程序行为进行扩展

Spring AOP和五种通知类型

一：Spring AOP几个核心概念：

二：面试Spring AOP的实现原理两种情况：
1、如果目标类实现接口，则spring优先底层使用JDK动态代理来生成目标类的代理，从而实现功能的扩展
2、如目标类没有实现接口，则spring自动使用CGLib通过继承的方式，对目标类进行扩展

三：五种通知类型

请介绍Spring的声明式事务

1、声明式事务是指利用AOP自动提交、回滚数据库事务
2、声明式事务规则进入方法打开事务，成功则提交事务，出现运行时异常则回滚事务
3、@Transactional是声明式事务的注解

4.Spring MVC

SpringMVC开发REST风格Web程序

一：使用springmvc实现Restful风格
1、Restful（表述性状态传递）以URL表示要访问的资源
2、GET/POST/PUT/DELETE对应查询、新增、更新、删除操作
3、Restful风格只响应数据不作任何页面跳转，通常是以JSON形式体现
&& applicationContext.xml配置

<!-- 配置扫描的包 -->
<context:component-scan base-package="com.imooc.interceptor"/>
<!--启用spring mvc 的注解开发模式-->
<mvc:annotation-driven></mvc:annotation-driven>
<!--访问静态资源排除-->
<mvc:default-servlet-handler/>

SpringMVC拦截器的作用

一：拦截器-Interceptor的作用
1、springmvc拦截器用于对URL请求(控制器方法)进行前置、后置处理
2、拦截器的底层实现技术是Spring AOP(面向切面编程)
3、拦截器必须实现HandlerInterceptor接口

二：拦截器的使用
1、实现HandlerInterceptor接口，并实现三个方法

/*** 拦截器*/
public class MyInterceptor implements HandlerInterceptor {/*** 前置执行处理*/@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println(request.getRequestURL() + "-准备执行-1");//true向后执行 false停止执行return true;}/*** 目标资源已被Spring mvc框架处理成功* @throws Exception*/@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println(request.getRequestURL() + "-目标资源已被Spring mvc框架处理成功-1");}/*** 响应文本已经产生*/@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println(request.getRequestURL() + "响应文本已经产生-1");}
}

2、在applicationContext.xml里面配置拦截器的三个方法的运行时机

<!--配置拦截器-->
<mvc:interceptors><mvc:interceptor><!--需要拦截的地址--><mvc:mapping path="/restful/**"/><mvc:mapping path="/webapi/**"/><!--静态资源排除不被拦截--><mvc:exclude-mapping path="/resources/**"/><!--自定义的拦截器--><bean class="com.imooc.interceptor.interceptor.MyInterceptor"/></mvc:interceptor>
</mvc:interceptors>

什么是SpringMvc，说一说它的几个核心组成？

① 前端控制器（DispatcherServlet）：主要用于接收客户端发送的 HTTP 请求、响应结果给客户端。
② 处理器映射器（HandlerMapping）：根据请求的 URL 来定位到对应的处理器（Handler）。
③ 处理器适配器（HandlerAdapter）：在编写处理器（Handler）的时候要按照处理器适配器（HandlerAdapter） 要求的规则去编写，通过适配器可以正确的去执行 Handler。
④ 处理器（Handler）：就是我们经常写的 Controller 层代码，例如：UserController。
⑤ 视图解析器（ViewResolver）：进行视图的解析，将 ModelAndView 对象解析成真正的视图（View）对象返回给前端控制器。
⑥ 视图（View）：View 是一个接口， 它的实现类支持不同的视图类型（JSP，FreeMarker，Thymleaf 等）。

SpringMVC的执行流程

关键步骤：
① 首先，用户发送 HTTP 请求给 SpringMVC 前端控制器 DispatcherServlet。
② DispatcherServlet 收到请求后，调用HandlerMapping 处理器映射器，根据请求 URL 去定位到具体的处理器 Handler，并将该处理器对象返回给 DispatcherServlet 。
③ 接下来，DispatcherServlet 调用 HandlerAdapter 处理器适配器，通过处理器适配器调用对应的 Handler 处理器处理请求，并向前端控制器返回一个 ModelAndView 对象。
④ 然后，DispatcherServlet 将 ModelAndView 对象交给 ViewResoler 视图解析器去处理，并返回指定的视图 View 给前端控制器。
⑤ DispatcherServlet 对 View 进行渲染（即将模型数据填充至视图中）。View 是一个接口， 它的实现类支持不同的视图类型（JSP，FreeMarker，Thymleaf 等）。
⑥ DispatcherServlet 将页面响应给用户。

详细执行步骤：
1、请求：用户发送请求至前端控制器DispatcherServlet，在spring mvc中所有请求都被DispatcherServlet拦截；
2、查找Handler(处理器)：DispatcherServlet收到请求调用HandlerMapping处理器映射器；
3、返回执行链：处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispathcerServlet；(可以把Handler当作控制器，HandlerMapper只会去获取执行链不会真正处理，而HandlerAdepter执行真正的方法)
4、请求执行Handler：Handler可能是拦截器也可能是控制器，HandlerAdapter根据Handler不同类型决定执行不同的方法；
5、执行目标方法：如果目标的Handler的实际类型是Interceptor拦截器就会执行前置的处理方法；但是Handler的实际类型为Controller控制器那就会进入控制器中对应的方法，来调用与url对应的方法
6、返回ModelAndView对象：Controller执行完成后返回ModelAndView对象，该对象会被HandlerAdapter接收；
7、返回ModelAndView对象：HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet；
8、选择对应视图解析器(freemarker)：DispatcherServlet将ModelAndView传给ViewResolver试图解析器；
9、返回view对象(视图模板)：ViewResolver解析后返回具体View；
10、渲染视图模板：DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）；
11、返回HTML：DispathcerServlet响应用户。

SpringBoot面试题

Spring、SpringMVC与SpringBoot的区别

1、Spring是所有应用的基础，提供了IOC与AOP特性
2、SpringMVC是Spring的子项目用于提供web支持
3、SpringBoot是Spring体系的敏捷开发框架，提高了开发效率

Spring Initializr 是创建 Spring BootProjects的唯一方法吗？

不是，可以直接到官网创建项目，会生成一个zip包，也可以直接使用maven项目，引入继承spring boot的依赖，引入需要的依赖等

SpringBoot支持2种配置文件

1、properties文件，如application.properties
单行进行书写。

server.por=8080
debug=false
server.servlet.context-path=/myspringboot
logging.file=d:/logs/msb.log

2、yaml文件，如application.yml
k:(空格)v：表示一对键值对（空格必须有）；
以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的

debug=false
server:port: 8080servlet:context-path: /
spring:mvc:date-format: yyyy-MM-dd

请列举至少五个SpringBoot中配置选项

Maven的构建生命周期

Mybatis

Mybatis的缓存机制

1、mybatis存在两级缓存
2、一级缓存与SqlSession会话绑定，默认开启
3、二级缓存是应用全局缓存，所有SqlSession共享

说明Mybatis的开发流程

1、引入mybatis依赖

<dependencies><!--mybatis依赖--><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.1</version></dependency><!--MySQL驱动--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.48</version></dependency><!--日志依赖--><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId><version>1.2.3</version></dependency><!--分页pagehelper--><dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId><version>5.2.0</version></dependency><!--jsqlparser 是pagehelper的底层依赖--><dependency><groupId>com.github.jsqlparser</groupId><artifactId>jsqlparser</artifactId><version>3.2</version></dependency>
</dependencies>

2、创建数据库配置文件mybatis-config.xml，连接数据库

<!-- 连接数据库 -->
<environments default="dev"><environment id="dev"><!-- 采用jdbc对数据库事务进行commit/rallback  --><transactionManager type="JDBC"></transactionManager><!-- 采用连接池方式管理数据库连接  --><dataSource type="POOLED"><property name="driver" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/babytun?useUnicode=true&amp;characterEncoding=UTF-8"/><property name="username" value="root"/><property name="password" value=""/></dataSource></environment>
</environments>

3、创建实体(Entity)类，如goods实体类
把底层的数据表与所定义的java实体类一一对应，同时数据表的字段与类的属性都有对应关系

4、在resources/mappers创建Mapper映射文件，goods.xml
mapper是mybatis把实体类与数据表进行映射的关键所在，通过mapper文件设置某个表和某个类是对应的，这个表的字段与这个类的那个属性是对应的

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace命名空间下 的id是唯一的 -->
<mapper namespace="goods"><!--开启二级缓存--><!--eviction是缓存的清除策略，当缓存对象数量达到上限后，自动触发对应算法对缓存对象清除1.LRU - 最近最久未使用：移除最长时间不被使用的对象【保证命中率，最常使用】对象数量：    O1  O2  O3 O4 .... O512访问间隔时间：14  88  63  1      6662.FIFO - 先进先出：按对象进入缓存的顺序来移除它们【无法保证命中率】3.SOFT - 软引用：移除基于垃圾收集器状态和软引用规则的对象4.WEAK - 弱引用：更积极的移除基于垃圾收集器状态和弱引用规则的对象。flushInterval：代表间隔多长时间自动清空缓存，单位毫秒，600000毫秒=10分钟size：缓存存储上限，用于保存对象或集合（1个集合算1个对象）的数量上限readOnly：设置为true，代表返回只读缓存，每次从缓存取出的是缓存对象本身，这种执行效率较高设置为false，代表每次取出的缓存对象的 "副本"，每次取出的对象都是不同的，这种安全性较高--><cache eviction="LRU" flushInterval="60000" size="512" readOnly="true"/><!--useCache="false" 不开启缓存--><select id="selectAll" resultType="com.imooc.mybatis.entity.Goods" useCache="false">select * from t_goods order by  goods_id desc limit 10</select><!--flushCache="true" 在sql执行完成后强制清空缓存--><!--<insert id="insert" parameterType="com.imooc.mybatis.entity.Goods" flushCache="true" useGeneratedKeys="true" keyProperty="goodsId" keyColumn="goods_id">--><!--&lt;!&ndash; sql语句 &ndash;&gt;--><!--</insert>--><!--flushCache="true" 在sql执行完成后强制清空缓存--><select id="selectById" parameterType="Integer" resultType="com.imooc.mybatis.entity.Goods" flushCache="false">select * from t_goods where goods_id = #{value}</select><select id="selectByPriceRange" parameterType="java.util.Map" resultType="com.imooc.mybatis.entity.Goods">select * from t_goodswherecurrent_price between #{min} and #{max}order by  current_price desc limit 0,#{limit}</select><!--多表关联查询结，利用LinkedHashMap保存多表关联结果mybatis会将每一条记录包装为LinkedHashMap对象key是字段名  value是字段对应的值，字段类型根据表结构进行字段判断优点：易于扩展，易于使用缺点：太过灵活，无法进行编译时检查--><select id="selectGoodsMap" resultType="java.util.LinkedHashMap">select g.*, c.category_namefrom  t_goods g, t_category cwhere g.category_id  = c.category_id</select><!--结果映射： 使用DTO对象接收 多表关联查询返回的结果集--><resultMap id="rmGoods" type="com.imooc.mybatis.dto.GoodsDTO"><!--goods表：设置主键--><id property="goods.goodsId" column="goods_id"/><!--goods表：除了id以外的字段--><result property="goods.title" column="title"/><result property="goods.subTitle" column="sub_title"/><result property="goods.originalCost" column="original_cost"/><result property="goods.currentPrice" column="current_price"/><result property="goods.discount" column="discount"/><result property="goods.isFreeDelivery" column="is_free_delivery"/><result property="goods.categoryId" column="category_id"/><!--category表：DTO的属性--><result property="category.categoryId" column="category_id"/><result property="category.categoryName" column="category_name"/><result property="category.parentId" column="parent_id"/><result property="category.categoryLevel" column="category_level"/><result property="category.categoryOrder" column="category_order"/><result property="test" column="test"/></resultMap><select id="selectGoodsDTO" resultMap="rmGoods">select g.*, c.*,'1' as testfrom  t_goods g, t_category cwhere g.category_id  = c.category_id</select><!--新增--><!--返回主键id方法1：useGeneratedKeys="true" keyProperty="goodsId" keyColumn="goods_id" --><insert id="insert" parameterType="com.imooc.mybatis.entity.Goods" useGeneratedKeys="true" keyProperty="goodsId" keyColumn="goods_id">insert into t_goods(title,sub_title,original_cost,current_price,discount,is_free_delivery,category_id)values (#{title},#{subTitle},#{originalCost},#{currentPrice},#{discount},#{isFreeDelivery},#{categoryId})<!--返回主键id方法2： 获取当前连接(新增数据)的id --><!--<selectKey resultType="Integer" keyProperty="goodsId" order="AFTER">select last_insert_id()</selectKey>--></insert><!--动态sql--><select id="dynamicSQL" parameterType="java.util.Map" resultType="com.imooc.mybatis.entity.Goods">select  * from  t_goods<!--使用 where 1=1 或者 <where>标签  --><where><if test="categoryId != null">and category_id = #{categoryId}</if><if test="currentPrice != null"><!-- &lt;为小于号。 -->and current_price &lt; #{currentPrice}</if></where></select><!--一对多关联查询resultMap 可用于说明一对多或者多对一的映射逻辑id 是resultMap属性引用的标志(关联select标签与resultMap标签)type 指向One的实体(Goods)--><resultMap id="rmGoods1" type="com.imooc.mybatis.entity.Goods"><!-- 映射goods对象的主建goods_id字段column-goods表的goods_id字段，property-goods类的goodsId属性--><id column="goods_id" property="goodsId"/><!--collection的含义是：在select * from t_goods limit 0,2 得到结果后，对所有Goods对象遍历得到goods_id字段值，并代入到goodsDetail命名空间的findByGoodsId的SQL中执行查询，将得到的 商品详情 集合赋值给 goodsDetails List对象。goods类的关联集合 List<GoodsDetail>property="goodsDetails"：为goods类的集合属性select="gxxx"：为goods_detail.xml的selectByGoodsIdcolumn="goods_id"：两表的关联外键(列)--><collection property="goodsDetails" select="goodsDetail.selectByGoodsId" column="goods_id"/></resultMap><select id="selectOneToMany" resultMap="rmGoods1">select * from t_goods limit 0,10</select><!--分页查询--><select id="selectPage" resultType="com.imooc.mybatis.entity.Goods">select * from t_goods where current_price &lt; 1000</select><!--批量插入--><!--批量插入数据的局限：1.无法获得插入数据的id2.批量生成的sql太长，可能会被服务器拒绝--><insert id="batchInsert" parameterType="java.util.List">insert into t_goods(title,sub_title,original_cost,current_price,discount,is_free_delivery,category_id)values<foreach collection="list" item="item" index="index" separator=",">(#{item.title},#{item.subTitle},#{item.originalCost},#{item.currentPrice},#{item.discount},#{item.isFreeDelivery},#{item.categoryId})</foreach></insert><!--批量删除--><!--in(1,2)--><delete id="batchDelete" parameterType="java.util.List">delete from t_goods where goods_id in<foreach collection="list" item="item" index="index" open="(" close=")" separator=",">#{item}</foreach></delete>
</mapper>

5、在mybatis-config.xml中对mapper的xml文件进行注册，通知mybatis这里有一个goods.xml

<!--配置指定xml目录路径，mybatis在初始化的时候才知道xml的存在-->
<mappers><mapper resource="mappers/goods.xml"/>
</mappers>

6、初始化SessionFactory
读取配置文件，加载映射文件，为后续的操作数据做准备
//获取mybatis配置文件
reader = Resources.getResourceAsReader(“mybatis-config.xml”);
//构建sqlSession工厂
sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
7、利用SqlSession对象操作数据

6和7的编码：

package com.imooc.mybatis.utils;import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;import java.io.IOException;
import java.io.Reader;/*** MybatisUtils工具类，创建全局唯一的SqlSessionFactory对象*/
public class MybatisUtils {//利用static关键字，属于类不属于对象，且全局唯一private static SqlSessionFactory sqlSessionFactory = null;//利用静态块在初始化类时实例化sqlSessionFactorystatic {Reader reader = null;try {//获取mybatis配置文件reader = Resources.getResourceAsReader("mybatis-config.xml");//构建sqlSession工厂sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);} catch (IOException e) {e.printStackTrace();//抛出初始化时出现的异常throw new ExceptionInInitializerError(e);}}/*** 利用SqlSession对象操作数据* openSession创建一个新的SqlSession对象* @return*/public static SqlSession openSession(){return sqlSessionFactory.openSession();}/*** 利用SqlSession对象操作数据* 是否一个有效的SqlSession对象* @param sqlSession*/public static void closeSession(SqlSession sqlSession){if (sqlSession != null){sqlSession.close();}}
}

Java主流框架面试题相关推荐

1. java 面试 框架_这份java集合框架面试题，轻松搞定面试官！

   集合框架 1. ArrayList 和 Vector 的区别. 这两个类都实现了 List 接口(List 接口继承了 Collection 接口),他们都是有序集 合,即存储在这两个集合中的元素的位 ...

2. java list有序还是无序_牛批！2w字的Java集合框架面试题精华集（2020最新版），赶紧收藏。...

   一个多月前,作者和一些小伙伴决定做一系列的 Java 知识点常见重要问题的小册,方便用来夯实基础!小册的标准就一个,那就是:取精华,取重点.每一本小册,我们都会充分关注我们所总结的知识点是否达到这个标 ...

3. java 三大框架面试题

   1.Hibernate工作原理及为什么要用? 原理: 1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory3.打开Session 4.创建事务Transation 5.持久 ...

4. 这八十一道java高级框架面试题你能答出多少题？

   话不多少直接上干货 1.什么是Maven? Maven使用项目对象模型(POM)的概念,可以通过一小段描述信息来管理项目的构建,报告和文档的软件项目管理工具. Maven 除了以程序构建能力为特色之外 ...

5. Java基础+框架 面试题

   第一轮面试题 面试题 第二轮面试题 Java基础 1.活字印刷,面向对象 2.面向对象原则 2.1 开放-封闭原则 白话解释:对于拓展是开放的,对于更改是封闭的 2.2依赖倒置原则 通俗解释:针对接口 ...

6. java主流框架使用排行，深度解析，值得收藏

   个人基本情况: 首先介绍一下自己的个人基本情况,某专科学校毕业,计算机技术与应用专业,有过2年的工作经验,毕业以后一直想要进入一线互联网大厂工作,但无奈学历受限,屡屡被挡在门外.后来接触到一个朋友,了 ...

7. Java初中级框架面试题

   Java初中级面试-框架篇 Spring 优缺点 优点 解耦:(IOC容器.DI操作) 简化开发:(学会的前提下) 支持AOP:(面向切面编程) 轻量级,非侵入式,支持整合各种框架(不排斥其它框架): ...

8. java ssh框架面试题_五道关于SSH框架的面试题

   1.写出你熟悉的开源框架以及各自的作用(项目中为什么使用SSH) 答:框架:hibernate,spring,struts1/struts2. Hibernate主要用于数据持久化:封装了JDBC操作 ...

9. 第 6-7 课：Java 分布式框架面试题合集

   1.什么是 ZooKeeper? 答:ZooKeeper 是一个开源的分布式应用程序协调服务,是一个典型的分布式数据一致性解决方案.设计目的是将那些复杂且容易出错的分布式一致性服务封装起来,构成一个高 ...

最新文章

1. table表格固定前几列，其余的滚动
2. ios 自定义UIView绘制时文字上下颠倒问题解决
3. matlab根据成绩划分等级_学生成绩分等级：ABCD,分优秀 良好合格 不及格,一组公式即可解决...
4. Java web.xml 配置详解
5. python求回数_用python求回数
6. easyui 扩展验证
7. python软件下载3版本-python
8. DevOps使用教程 华为云（15）git如何将本地项目初始化为远程仓库
9. ARMv8-A Generic Interrupt Controller(GIC)
10. springMVC Model ModelMap 和 ModelAndView的区别
11. python2.7详细安装教程_python2.7安装图文教程
12. 很不错的在线Office控件：IWebOffice与SOAOffice
13. 最网最全python框架--scrapy（体系学习，爬取全站校花图片），学完显著提高爬虫能力（附源代码），突破各种反爬
14. Win10_ltsc_2019_x64集成DPO基于人工智能优化可动态提高应用程序性能提升高达394%
15. 【开发教程9】疯壳·开源蓝牙心率防水运动手环-心率监测
16. eplan长时间不用打开后显示没有可激活合适的加密狗
17. matlab 双峰,如何在MATLAB中区分双峰和单峰阵列？
18. linux下 部署调用SAP接口
19. 保险公司真得保险么？
20. GMap地图的加载和现实

热门文章

1. 高仿Gnote笔记，一个笔记带你了解完整的app架构
2. 如何隐藏您在Apple App Store和Google Play上购买的应用程序
3. iMove 如何输出影片、mp4 档案格式及调整画质？
4. 哪里有挣快钱的低成本项目的好路子？
5. DvaJS学习（dva = React-Router + Redux + Redux-saga）
6. 07.阿里云RDS数据库的基本操作
7. OFweek 2019智慧城市发展高峰论坛圆满举行
8. webpack优化系列(1)-HMR
9. 【图像分割-阈值分割】基于灰狼算法二维oust图像分割附matlab代码
10. 企业级memcached部署(session共享)