SpringMVC学习笔记

最新推荐文章于 2023-03-07 21:09:45 发布
最新推荐文章于 2023-03-07 21:09:45 发布
阅读量692 收藏
点赞数 1
分类专栏： Java 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18515155/article/details/117426828
版权

文章目录

1.1 Spring MVC 简介

1.1.1 MVC 体系结构

  • 表现层，处理web请求
  • 业务层，处理业务逻辑
  • 持久层，数据持久化

MVC设计模式

  • Model（模型），模型包含业务模型和数据模型，数据模型⽤于封装数据，业务模型⽤于处理业
    务。
  • View（视图），通常指的就是我们的 jsp 或者 html。作⽤⼀般就是展示数据的。通常视图是依据
    模型数据创建的。
  • Controller（控制器）： 是应⽤程序中处理⽤户交互的部分。作⽤⼀般就是处理程序逻辑的。
    MVC提倡：每⼀层只编写⾃⼰的东⻄，不编写任何其他的代码；分层是为了解耦，解耦是为了维
    护⽅便和分⼯协作。

1.1.2 SpringMVC介绍

SpringMVC 全名叫 Spring Web MVC，是⼀种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级
Web 框架。

Spring MVC 本质可以认为是对servlet的封装，简化了我们serlvet的开发。

1.2 SpringMVC请求处理流程

在这里插入图片描述

流程说明：
第⼀步：⽤户发送请求⾄前端控制器DispatcherServlet
第⼆步： DispatcherServlet收到请求调⽤HandlerMapping处理器映射器
第三步：处理器映射器根据请求Url找到具体的Handler（后端控制器），⽣成处理器对象及处理器拦截
器(如果 有则⽣成)⼀并返回DispatcherServlet
第四步： DispatcherServlet调⽤HandlerAdapter处理器适配器去调⽤Handler
第五步：处理器适配器执⾏Handler
第六步： Handler执⾏完成给处理器适配器返回ModelAndView
第七步：处理器适配器向前端控制器返回 ModelAndView， ModelAndView 是SpringMVC 框架的⼀个
底层对 象，包括 Model 和 View
第⼋步：前端控制器请求视图解析器去进⾏视图解析，根据逻辑视图名来解析真正的视图。
第九步：视图解析器向前端控制器返回View
第⼗步：前端控制器进⾏视图渲染，就是将模型数据（在 ModelAndView 对象中）填充到 request 域
第⼗⼀步：前端控制器向⽤户响应结果

1.3 参数绑定

注册自定义类型转换器：

<!--
⾃动注册最合适的处理器映射器，处理器适配器(调⽤handler⽅法)
-->
<mvc:annotation-driven conversionservice="conversionServiceBean"/>
<!--注册⾃定义类型转换器-->
<bean id="conversionServiceBean"
class="org.springframework.format.support.FormattingConversionServiceF
actoryBean">
<property name="converters">
<set>
<bean class="com.lagou.edu.converter.DateConverter">
</bean>
</set>
</property>
</bean>

1.4 RESTful支持

Restful 是⼀种 web 软件架构⻛格，它不是标准也不是协议，它倡导的是⼀个资源定位及资源操作的⻛
格。

/account/1 HTTP GET ：得到 id = 1 的 account
/account/1 HTTP DELETE：删除 id = 1 的 account
/account/1 HTTP PUT：更新 id = 1 的 account

依赖注解@PathVariable

form表单只支持get和post，对于post如何支持put和delete呢？

答：web.xml中配置请求⽅式过滤器（将特定的post请求转换为put和delete请求）

<!--配置springmvc请求⽅式转换过滤器，会检查请求参数中是否有_method参数，如果有就
按照指定的请求⽅式进⾏转换-->
<filter>
<filter-name>hiddenHttpMethodFilter</filter-name>
<filterclass>org.springframework.web.filter.HiddenHttpMethodFilter</filterclass>
</filter>
<filter-mapping>
<filter-name>encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>hiddenHttpMethodFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

1.5 和Ajax Json交互

交互：两个⽅向
1）前端到后台：前端ajax发送json格式字符串，后台直接接收为pojo参数，使⽤注解@RequstBody
2）后台到前端：后台直接返回pojo对象，前端直接接收为json对象或者字符串，使⽤注解
@ResponseBody

默认使用jackson序列化和反序列化。

第⼆部分 Spring MVC ⾼级技术

1.1 拦截器(Inteceptor)使⽤

1.1.1 监听器、过滤器和拦截器

Servlet：处理Request请求和Response响应
过滤器（Filter）：对Request请求起到过滤的作⽤，作⽤在Servlet之前，如果配置为/*可
有的资源访问（servlet、 js/css静态资源等）进⾏过滤处理
监听器（Listener）：实现了javax.servlet.ServletContextListener 接⼝的服务器端组件
Web应⽤的启动⽽启动，只初始化⼀次，然后会⼀直运⾏监视，随Web应⽤的停⽌⽽销毁

  • 作⽤⼀： 做⼀些初始化⼯作， web应⽤中spring容器启动ContextLoaderListener
  • 作⽤⼆： 监听web中的特定事件，⽐如HttpSession,ServletRequest的创建和销毁；变量
    销毁和修改等。可以在某些动作前后增加处理，实现监控，⽐如统计在线⼈数，利⽤
    HttpSessionLisener等。

拦截器（Interceptor）：是SpringMVC、 Struts等表现层框架⾃⼰的，不会拦截
jsp/html/css/image的访问等，只会拦截访问的控制器⽅法（Handler）。

1.1.2 拦截器的执⾏流程

在这里插入图片描述

1）程序先执⾏preHandle()⽅法，如果该⽅法的返回值为true，则程序会继续向下执⾏处理器中的⽅
法，否则将不再向下执⾏。
2）在业务处理器（即控制器Controller类）处理完请求后，会执⾏postHandle()⽅法，然后会通过
DispatcherServlet向客户端返回响应。
3）在DispatcherServlet处理完请求后，才会执⾏afterCompletion()⽅法。

1.1.3 多个拦截器的执⾏流程

在这里插入图片描述

执行preHandler()是顺序执行，执行postHandle()⽅法和afterCompletion()是逆序执行。

1.2 处理multipart形式的数据

配置⽂件上传解析器：

<!--配置⽂件上传解析器， id是固定的multipartResolver-->
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!--设置上传⼤⼩，单位字节-->
<property name="maxUploadSize" value="1000000000"/>
</bean>

后台接受参数使用MultipartFile

1.3 在控制器中处理异常

@ControllerAdvice+@ExceptionHandler(ArithmeticException.class)

@ControllerAdvice
public class GlobalExceptionResolver {
@ExceptionHandler(ArithmeticException.class)
public ModelAndView handleException(ArithmeticException exception,
HttpServletResponse response) {
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("msg",exception.getMessage());
modelAndView.setViewName("error");
return modelAndView;
}
}

1.4 重定向请求参数传递

重定向时请求参数会丢失，我们往往需要重新携带请求参数，我们可以进⾏⼿动参数拼接如下：

return "redirect:handle01?name=" + name;

但是上述拼接参数的⽅法属于get请求，携带参数⻓度有限制，参数安全性也不⾼，此时，我们可以使
⽤SpringMVC提供的flash属性机制，向上下⽂中添加flash属性，框架会在session中记录该属性值，当
跳转到⻚⾯之后框架会⾃动删除flash属性，不需要我们⼿动删除，通过这种⽅式进⾏重定向参数传递，
参数⻓度和安全性都得到了保障，如下：

/**
* SpringMVC 重定向时参数传递的问题
* 转发： A 找 B 借钱400， B没有钱但是悄悄的找到C借了400块钱给A
* url不会变,参数也不会丢失,⼀个请求
* 重定向： A 找 B 借钱400， B 说我没有钱，你找别⼈借去，那么A ⼜带着400块的借钱需求找到
C
* url会变,参数会丢失需要重新携带参数,两个请求
*/
@RequestMapping("/handleRedirect")
public String handleRedirect(String name,RedirectAttributes
redirectAttributes) {
//return "redirect:handle01?name=" + name; // 拼接参数安全性、参数⻓度都有
局限
// addFlashAttribute⽅法设置了⼀个flash类型属性，该属性会被暂存到session中，在
跳转到⻚⾯之后该属性销毁
redirectAttributes.addFlashAttribute("name",name);
return "redirect:handle01";
}

第三部分 ⼿写 MVC 框架

SpringMVC执行的大致原理如下：

在这里插入图片描述

根据上面的分析，手动实现每一个步骤即可。

主要关注第三步和第四步：

public class LgDispatcherServlet extends HttpServlet {
private Properties properties = new Properties();
private List<String> classNames = new ArrayList<>(); // 缓存扫描到的类的
全限定类名
// ioc容器
private Map<String,Object> ioc = new HashMap<String,Object>();
// handlerMapping
//private Map<String,Method> handlerMapping = now HashMap<>(); // 存储
url和Method之间的映射关系
private List<Handler> handlerMapping = new ArrayList<>();
@Override
public void init(ServletConfig config) throws ServletException {
// 1 加载配置⽂件 springmvc.properties
String contextConfigLocation =
config.getInitParameter("contextConfigLocation");
doLoadConfig(contextConfigLocation);
// 2 扫描相关的类，扫描注解
doScan(properties.getProperty("scanPackage"));
// 3 初始化bean对象（实现ioc容器，基于注解）
doInstance();
// 4 实现依赖注⼊
doAutoWired();
// 5 构造⼀个HandlerMapping处理器映射器，将配置好的url和Method建⽴映射关系
initHandlerMapping();
System.out.println("lagou mvc 初始化完成....");
// 等待请求进⼊，处理请求
}
/*
构造⼀个HandlerMapping处理器映射器
最关键的环节
⽬的：将url和method建⽴关联
*/
private void initHandlerMapping() {
if(ioc.isEmpty()) {return;}
for(Map.Entry<String,Object> entry: ioc.entrySet()) {
// 获取ioc中当前遍历的对象的class类型
Class<?> aClass = entry.getValue().getClass();
if(!aClass.isAnnotationPresent(LagouController.class))
{continue;}
String baseUrl = "";
if(aClass.isAnnotationPresent(LagouRequestMapping.class)) {
LagouRequestMapping annotation =
aClass.getAnnotation(LagouRequestMapping.class);
baseUrl = annotation.value(); // 等同于/demo
}
// 获取⽅法
Method[] methods = aClass.getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
// ⽅法没有标识LagouRequestMapping，就不处理
if(!method.isAnnotationPresent(LagouRequestMapping.class))
{continue;}
// 如果标识，就处理
LagouRequestMapping annotation =
method.getAnnotation(LagouRequestMapping.class);
String methodUrl = annotation.value(); // /query
String url = baseUrl + methodUrl; // 计算出来的url
/demo/query
// 把method所有信息及url封装为⼀个Handler
Handler handler = new Handler(entry.getValue(),method,
Pattern.compile(url));
// 计算⽅法的参数位置信息 // query(HttpServletRequest
request, HttpServletResponse response,String name)
Parameter[] parameters = method.getParameters();
for (int j = 0; j < parameters.length; j++) {
Parameter parameter = parameters[j];
if(parameter.getType() == HttpServletRequest.class ||
parameter.getType() == HttpServletResponse.class) {
// 如果是request和response对象，那么参数名称写
HttpServletRequest和HttpServletResponse
handler.getParamIndexMapping().put(parameter.getType().getSimpleName(),j)
;
}else{
handler.getParamIndexMapping().put(parameter.getName(),j); // <name,2>
}
}
// 建⽴url和method之间的映射关系（map缓存起来）
handlerMapping.add(handler);
}
}
}
// 实现依赖注⼊
private void doAutoWired() {
if(ioc.isEmpty()) {return;}
// 有对象，再进⾏依赖注⼊处理
// 遍历ioc中所有对象，查看对象中的字段，是否有@LagouAutowired注解，如果有需
要维护依赖注⼊关系
for(Map.Entry<String,Object> entry: ioc.entrySet()) {
// 获取bean对象中的字段信息
Field[] declaredFields =
entry.getValue().getClass().getDeclaredFields();
// 遍历判断处理
for (int i = 0; i < declaredFields.length; i++) {
Field declaredField = declaredFields[i]; //
@LagouAutowired private IDemoService demoService;
if(!declaredField.isAnnotationPresent(LagouAutowired.class)) {
continue;
}
// 有该注解
LagouAutowired annotation =
declaredField.getAnnotation(LagouAutowired.class);
String beanName = annotation.value(); // 需要注⼊的bean的id
if("".equals(beanName.trim())) {
// 没有配置具体的bean id，那就需要根据当前字段类型注⼊（接⼝注
⼊） IDemoService
beanName = declaredField.getType().getName();
}
// 开启赋值
declaredField.setAccessible(true);
try {
declaredField.set(entry.getValue(),ioc.get(beanName));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
// ioc容器
// 基于classNames缓存的类的全限定类名，以及反射技术，完成对象创建和管理
private void doInstance() {
  if(classNames.size() == 0) return;
try{
for (int i = 0; i < classNames.size(); i++) {
String className = classNames.get(i); //
com.lagou.demo.controller.DemoController
// 反射
Class<?> aClass = Class.forName(className);
// 区分controller，区分service'
if(aClass.isAnnotationPresent(LagouController.class)) {
// controller的id此处不做过多处理，不取value了，就拿类的⾸字
⺟⼩写作为id，保存到ioc中
String simpleName = aClass.getSimpleName();//
DemoController
String lowerFirstSimpleName = lowerFirst(simpleName);
// demoController
Object o = aClass.newInstance();
ioc.put(lowerFirstSimpleName,o);
}else if(aClass.isAnnotationPresent(LagouService.class)) {
LagouService annotation =
aClass.getAnnotation(LagouService.class);
//获取注解value值
String beanName = annotation.value();
// 如果指定了id，就以指定的为准
if(!"".equals(beanName.trim())) {
ioc.put(beanName,aClass.newInstance());
}else{
// 如果没有指定，就以类名⾸字⺟⼩写
beanName = lowerFirst(aClass.getSimpleName());
ioc.put(beanName,aClass.newInstance());
}
// service层往往是有接⼝的，⾯向接⼝开发，此时再以接⼝名为id，
放⼊⼀份对象到ioc中，便于后期根据接⼝类型注⼊
Class<?>[] interfaces = aClass.getInterfaces();
for (int j = 0; j < interfaces.length; j++) {
Class<?> anInterface = interfaces[j];
// 以接⼝的全限定类名作为id放⼊
ioc.put(anInterface.getName(),aClass.newInstance());
}
}else{
continue;
}
}
}catch (Exception e) {
e.printStackTrace();
}
}
// ⾸字⺟⼩写⽅法
public String lowerFirst(String str) {
char[] chars = str.toCharArray();
if('A' <= chars[0] && chars[0] <= 'Z') {
chars[0] += 32;
}
return String.valueOf(chars);
}
// 扫描类
// scanPackage: com.lagou.demo package----> 磁盘上的⽂件夹（File）
com/lagou/demo
private void doScan(String scanPackage) {
String scanPackagePath =
Thread.currentThread().getContextClassLoader().getResource("").getPath() +
scanPackage.replaceAll("\\.", "/");
File pack = new File(scanPackagePath);
File[] files = pack.listFiles();
for(File file: files) {
if(file.isDirectory()) { // ⼦package
// 递归
doScan(scanPackage + "." + file.getName()); //
com.lagou.demo.controller
}else if(file.getName().endsWith(".class")) {
String className = scanPackage + "." +
file.getName().replaceAll(".class", "");
classNames.add(className);
}
}
}
// 加载配置⽂件
private void doLoadConfig(String contextConfigLocation) {
InputStream resourceAsStream =
this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation
);
try {
properties.load(resourceAsStream);
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
doPost(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse
resp) throws ServletException, IOException {
// 处理请求：根据url，找到对应的Method⽅法，进⾏调⽤
// 获取uri
// String requestURI = req.getRequestURI();
// Method method = handlerMapping.get(requestURI);// 获取到⼀个反射的
⽅法
// 反射调⽤，需要传⼊对象，需要传⼊参数，此处⽆法完成调⽤，没有把对象缓存起来，
也没有参数！！！！改造initHandlerMapping();
// method.invoke() //
// 根据uri获取到能够处理当前请求的hanlder（从handlermapping中（list））
Handler handler = getHandler(req);
if(handler == null) {
resp.getWriter().write("404 not found");
return;
}
// 参数绑定
// 获取所有参数类型数组，这个数组的⻓度就是我们最后要传⼊的args数组的⻓度
Class<?>[] parameterTypes =
handler.getMethod().getParameterTypes();
// 根据上述数组⻓度创建⼀个新的数组（参数数组，是要传⼊反射调⽤的）
Object[] paraValues = new Object[parameterTypes.length];
// 以下就是为了向参数数组中塞值，⽽且还得保证参数的顺序和⽅法中形参顺序⼀致
Map<String, String[]> parameterMap = req.getParameterMap();
// 遍历request中所有参数 （填充除了request， response之外的参数）
for(Map.Entry<String,String[]> param: parameterMap.entrySet()) {
// name=1&name=2 name [1,2]
String value = StringUtils.join(param.getValue(), ","); // 如
同 1,2
// 如果参数和⽅法中的参数匹配上了，填充数据
if(!handler.getParamIndexMapping().containsKey(param.getKey()))
{continue;}
// ⽅法形参确实有该参数，找到它的索引位置，对应的把参数值放⼊paraValues
Integer index =
handler.getParamIndexMapping().get(param.getKey());//name在第 2 个位置
paraValues[index] = value; // 把前台传递过来的参数值填充到对应的位置
去
}
int requestIndex =
handler.getParamIndexMapping().get(HttpServletRequest.class.getSimpleName(
)); // 0
paraValues[requestIndex] = req;
int responseIndex =
handler.getParamIndexMapping().get(HttpServletResponse.class.getSimpleName
()); // 1
paraValues[responseIndex] = resp;
// 最终调⽤handler的method属性
try {
  handler.getMethod().invoke(handler.getController(),paraValues);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
private Handler getHandler(HttpServletRequest req) {
if(handlerMapping.isEmpty()){return null;}
String url = req.getRequestURI();
for(Handler handler: handlerMapping) {
Matcher matcher = handler.getPattern().matcher(url);
if(!matcher.matches()){continue;}
return handler;
}
return null;
}
}



/**
* 封装handler⽅法相关的信息
*/
public class Handler {
private Object controller; // method.invoke(obj,)
private Method method;
  private Pattern pattern; // spring中url是⽀持正则的
private Map<String,Integer> paramIndexMapping; // 参数顺序,是为了进⾏参数
绑定， key是参数名， value代表是第⼏个参数 <name,2>
public Handler(Object controller, Method method, Pattern pattern) {
this.controller = controller;
this.method = method;
this.pattern = pattern;
this.paramIndexMapping = new HashMap<>();
}
public Object getController() {
return controller;
}
public void setController(Object controller) {
this.controller = controller;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}
public Pattern getPattern() {
return pattern;
}
public void setPattern(Pattern pattern) {
this.pattern = pattern;
}
public Map<String, Integer> getParamIndexMapping() {
return paramIndexMapping;
}
public void setParamIndexMapping(Map<String, Integer>
paramIndexMapping) {
this.paramIndexMapping = paramIndexMapping;
}
}

第四部分 Spring MVC 源码深度剖析

SpringMVC处理请求的流程即为
org.springframework.web.servlet.DispatcherServlet#doDispatch⽅法的执⾏过程，其中步骤
2、 3、 4、 5是核⼼步骤
1）调⽤getHandler()获取到能够处理当前请求的执⾏链 HandlerExecutionChain（Handler+拦截
器）
2）调⽤getHandlerAdapter()；获取能够执⾏1）中Handler的适配器
3）适配器调⽤Handler执⾏ha.handle（总会返回⼀个ModelAndView对象）
4）调⽤processDispatchResult()⽅法完成视图渲染跳转

第五部分 SSM 整合

1.1 Mybatis整合Spring

pom依赖

<!--junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<!--spring相关-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<dependency>jdbc.properties
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
<!--mybatis与spring的整合包-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.3</version>
</dependency>
<!--数据库驱动jar-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
<!--druid连接池-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.21</version>
</dependency>

applicationContext-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
">
<!--包扫描-->
<context:component-scan base-package="com.lagou.edu.mapper"/>
<!--数据库连接池以及事务管理都交给Spring容器来完成-->
<!--引⼊外部资源⽂件-->
<context:property-placeholder
location="classpath:jdbc.properties"/>
<!--第三⽅jar中的bean定义在xml中-->
<bean id="dataSource"
class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!--SqlSessionFactory对象应该放到Spring容器中作为单例对象管理
原来mybaits中sqlSessionFactory的构建是需要素材的： SqlMapConfig.xml中的内
容
-->
<bean id="sqlSessionFactory"
class="org.mybatis.spring.SqlSessionFactoryBean">
<!--别名映射扫描-->
<property name="typeAliasesPackage" value="com.lagou.edu.pojo"/>
<!--数据源dataSource-->
<property name="dataSource" ref="dataSource"/>
</bean>
<!--Mapper动态代理对象交给Spring管理，我们从Spring容器中直接获得Mapper的代理对
象-->
<!--扫描mapper接⼝，⽣成代理对象，⽣成的代理对象会存储在ioc容器中-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--mapper接⼝包路径配置-->
<property name="basePackage" value="com.lagou.edu.mapper"/>
<property name="sqlSessionFactoryBeanName"
value="sqlSessionFactory"/>
</bean>
</beans>

applicationContext-service.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:lgContext="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
">
<!--包扫描-->
<lgContext:component-scan base-package="com.lagou.edu.service"/>
<!--事务管理-->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--事务管理注解驱动-->
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

1.2 整合SpringMVC

pom文件

<!--SpringMVC-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<!--jsp-api&servlet-api-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!--⻚⾯使⽤jstl表达式-->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>
<!--json数据交互所需jar， start-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>
<!--json数据交互所需jar， end-->

springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/springcontext.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
">
<!--扫描controller-->
<context:component-scan base-package="com.lagou.edu.controller"/>
<mvc:annotation-driven/>
</beans>

web.xml

<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:applicationContext*.xml</param-value>
</context-param>
<!--spring框架启动-->
<listener>
<listenerclass>org.springframework.web.context.ContextLoaderListener</listenerclass>
</listener>
<!--springmvc启动-->
<servlet>
<servlet-name>springmvc</servlet-name>
<servletclass>org.springframework.web.servlet.DispatcherServlet</servletclass>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

第六部分 Spring Data JPA

1.1 Spring Data JPA 概述

Spring Data JPA 是 Spring 基于JPA 规范的基础上封装的⼀套 JPA 应⽤框架，可使开发者⽤极简的
代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常⽤功能！学习并使⽤
Spring Data JPA 可以极⼤提⾼开发效率

1.2 Spring Data JPA， JPA规范和Hibernate之间的

关系

在这里插入图片描述

Spring Data JPA是基于Hibernate来实现的。

1.3 Spring Data JPA 应⽤

1.3.1 接入Spring Data JPA

pom文件

<dependencies>
<!--单元测试jar-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--spring-data-jpa 需要引⼊的jar,start-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>2.1.8.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>3.0.1-b04</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.6</version>
</dependency>
<!--spring-data-jpa 需要引⼊的jar,end-->
<!--spring 相关jar,start-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<!--spring对orm框架的⽀持包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
<!--spring 相关jar,end-->
<!--hibernate相关jar包,start-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.4.0.Final</version>
</dependency>
<!--hibernate对jpa的实现jar-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>5.4.0.Final</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.4.0.Final</version>
</dependency>
<!--hibernate相关jar包,end-->
<!--mysql 数据库驱动jar-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.46</version>
</dependency>
<!--druid连接池-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.21</version>
</dependency>
<!--spring-test-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.12.RELEASE</version>
</dependency>
</dependencies>

spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/data/jpa
https://www.springframework.org/schema/data/jpa/spring-jpa.xsd
">
<!--对Spring和SpringDataJPA进⾏配置-->
<!--1、创建数据库连接池druid-->
<!--引⼊外部资源⽂件-->
<context:property-placeholder
location="classpath:jdbc.properties"/>
<!--第三⽅jar中的bean定义在xml中--><bean id="dataSource"
class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!--2、配置⼀个JPA中⾮常重要的对象,entityManagerFactory
entityManager类似于mybatis中的SqlSession
entityManagerFactory类似于Mybatis中的SqlSessionFactory
-->
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
>
<!--配置⼀些细节.......-->
<!--配置数据源-->
<property name="dataSource" ref="dataSource"/>
<!--配置包扫描（pojo实体类所在的包） -->
<property name="packagesToScan"
value="com.lagou.edu.pojo"/>
<!--指定jpa的具体实现，也就是hibernate-->
<property name="persistenceProvider">
<bean
class="org.hibernate.jpa.HibernatePersistenceProvider"></bean>
</property>
<!--jpa⽅⾔配置,不同的jpa实现对于类似于beginTransaction等细节实现
起来是不⼀样的，
所以传⼊JpaDialect具体的实现类-->
<property name="jpaDialect">
<bean
class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"></bean>
</property>
<!--配置具体provider， hibearnte框架的执⾏细节-->
<property name="jpaVendorAdapter" >
<bean
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!--定义hibernate框架的⼀些细节-->
<!--
配置数据表是否⾃动创建因为我们会建⽴pojo和数据表之间的映射关系
程序启动时，如果数据表还没有创建，是否要程序给创建⼀下
-->
<property name="generateDdl" value="false"/>
<!--
指定数据库的类型
hibernate本身是个dao层框架，可以⽀持多种数据库类型
的，这⾥就指定本次使⽤的什么数据库
-->
<property name="database" value="MYSQL"/>
<!--
配置数据库的⽅⾔
hiberante可以帮助我们拼装sql语句，但是不同的数据库sql
语法是不同的，所以需要我们注⼊具体的数据库⽅⾔
-->
<property name="databasePlatform"
value="org.hibernate.dialect.MySQLDialect"/>
<!--是否显示sql
操作数据库时，是否打印sql
-->
<property name="showSql" value="true"/>
</bean>
</property>
</bean>
<!--3、引⽤上⾯创建的entityManagerFactory
<jpa:repositories> 配置jpa的dao层细节
base-package:指定dao层接⼝所在包
-->
<jpa:repositories base-package="com.lagou.edu.dao" entity-managerfactory-ref="entityManagerFactory"
transaction-manager-ref="transactionManager"/>
<!--4、事务管理器配置
jdbcTemplate/mybatis 使⽤的是DataSourceTransactionManager
jpa规范： JpaTransactionManager
-->
<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>
<!--5、声明式事务配置-->
<!--
<tx:annotation-driven/>
-->
<!--6、配置spring包扫描-->
<context:component-scan base-package="com.lagou.edu"/>
</beans>

注意：

对于事务管理器，spring jdbcTemplate、mybatis 使⽤的是DataSourceTransactionManager；spring data jpa使用的是JpaTransactionManager；hibernate使用的是HibernateTransactionManager。

这三个事务管理器都是Spring 事务管理器接口PlatformTransactionManager接口的实现。

1.3.2 基本使用

实体类：

使用到的ORM注解：@Entity、@Table(name = “tb_resume”)、@Id、@GeneratedValue(strategy = GenerationType.IDENTITY)、@Column(name = “id”)

Dao层接口：

/**
* ⼀个符合SpringDataJpa要求的Dao层接⼝是需要继承JpaRepository和
JpaSpecificationExecutor
*
* JpaRepository<操作的实体类类型,主键类型>
* 封装了基本的CRUD操作
*
* JpaSpecificationExecutor<操作的实体类类型>
* 封装了复杂的查询（分⻚、排序等）
*
*/
public interface ResumeDao extends JpaRepository<Resume,Long>,
JpaSpecificationExecutor<Resume> {
@Query("from Resume where id=?1 and name=?2")
public List<Resume> findByJpql(Long id,String name);
/**
* 使⽤原⽣sql语句查询，需要将nativeQuery属性设置为true，默认为false（jpql）
* @param name
* @param address
* @return
*/
@Query(value = "select * from tb_resume where name like ?1 and
address like ?2",nativeQuery = true)
public List<Resume> findBySql(String name,String address);
/**
* ⽅法命名规则查询
* 按照name模糊查询（like）
* ⽅法名以findBy开头
* -属性名（⾸字⺟⼤写）
* -查询⽅式（模糊查询、等价查询），如果不写查询⽅式，默认等价
查询
*/
public List<Resume> findByNameLikeAndAddress(String name,String
address);
}

1.4 实现原理

和Mybatis一样也是基于JDK动态代理实现（Spring AOP中JDK动态代理的实现）。

墨、鱼
关注
专栏目录
SpringMVC的基础内容+核心知识
python_777的博客
08-20 185
SpringMVC： SpringMVC是基于Spring的一个部件，专门来处理客户端与服务器之间的交互，通过controller(控制器)将model(底层数据)返回到view(视图页面)。 SpringMVC与servlet+jsp的区别 1.在BS架构中，原始的servlet+jsp中，从客户端发起的请求到servlet中，servlet对数据处理返回给jsp界面，servlet充当了controller, 学习时间： 提示：这里可以添加计划学习的时间 例如： 1、 周一至周五晚上 7 点—晚上9点
SpringMVC学习笔记：SpringMVC
qq_49019244的博客
02-20 183
学习内容：SpringMVC 一、什么是MVC MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。是将业务逻辑、数据、显示分离的方法来组织代码。MVC主要作用是降低了视图与业务逻辑间的双向偶合。 在MVC设计思想中要求一个符合MVC设计思想的软件应该保证上面这三部分相互独立，互不干扰，每一个部分只负责自己擅长的部分。如果某一个模块发生变化，应该尽量做到不影响其他两个模块。提高代码的可读性，实现程序间的松耦合、提高代码复用性。 Model（模型）：数据模型
VUE基础语法(带扩展):axios异步请求&事件绑定&事件修饰符&按键修饰符&数据显示&列表渲染&条件渲染&生命周期
at10090的博客
10-08 2470
1 Vue概述 1.1 VueJS介绍 Vue.js是一个构建数据驱动的 web 界面的渐进式框架。Vue.js 的目标是通过尽可能简单的 API 实现响应的数据绑定和组合的视图组件。它不仅易于上手，还便于与第三方库或既有项目整合。 官网:https://cn.vuejs.org/ 1.2 MVVM模式 MVVM是Model-View-ViewModel的简写。它本质上就是MVC 的改进版。MVV...
SpringMvc学习笔记（基础+详细）
热门推荐
qq_40608425的博客
08-04 1万+
本人技术小白，学习SpringMvc后，将相关内容整理下来，供大家分享，欢迎批评指正。 本文主要介绍如下方面相关知识，并分为不同章节，大家可根据自身需求选择性阅读： SpirngMvc的HelloWorld（一个SpringMvc实例的简单流程） 使用@RequestMapping映射请求 映射请求参数、请求头 处理模型数据 视图和视图解析器 数据转换、校验、格式化 文件的上传 ...
Spring配置文件中xsd版本号的问题
克格莫（有需要的私信）
01-29 5419
今天将以前的一个项目移植到新机器上开发，在原本的机器上跑得好好的项目移植过来之后报了个莫名其妙的错： 在xml中给我说xsd的版本不对，于是将原本的如下代码片： xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.
springmvc学习笔记
10-28
springmvc学习笔记
SpringMVC学习笔记.zip
04-12
SpringMVC是Java web开发中一个非常重要的框架，它基于模型-视图-控制器（Model-View-Controller）设计模式...这份“SpringMVC学习笔记”包括了从基础到进阶的全面内容，旨在帮助读者从零开始掌握SpringMVC的各个方面。
springmvc学习笔记-springmvc注解开发.zip
最新发布
05-10
在"springmvc学习笔记--springmvc注解开发.zip"这个压缩包中，我们可以深入探讨Spring MVC的注解驱动开发方式，这是一种简洁且高效的开发模式。 1. **Spring MVC基础**： Spring MVC的核心组件包括...
Spring SpringMVC JPA整合配置
metjoyful的博客
09-26 4496
1. 三大框架 ssh struts spring hibernate Struts2 Spring Hibernate ssm(目前最流行的框架) SpringMVC Spring MyBatis ssj(Spring springMvc jpa) Struts2 Spring JPA(过时) SpringMVC Spring JPA（今天集成的框架） SpringMVC Spri...
GitLab的Webhook配置和开发
徐小陌的博客
12-07 1万+
基于GitLab的Webhook对Merge Request和Tag Push事件自动发送企业微信通知。
一个简单的Java抽奖程序
徐小陌的博客
05-21 6770
文章目录需求背景设计思路代码实现定义奖品及中奖概率执行抽奖中奖率测试测试结果数据 本文逻辑思想比较简单，旨在了解后端如何设计抽奖以及控制抽奖概率。 需求背景 现在奖品池有如下奖品： 序号 名称 中奖率 0 代金券10元 20% 1 代金券50元 14% 2 蓝牙耳机 10% 3 Switch游戏机 5% 4 iPhone 13Pro 1% 5 谢谢参与 50% 需要设计一个抽奖程序，保证最终的抽奖结果近可能贴近每个奖品的中奖率。 设计思路 首先看看现实生活中的抽奖
SpringBoot中Jackson序列化处理自定义注解
徐小陌的博客
03-07 4744
上篇文章 Jackson序列化带有注解的字段的原理浅析 里已经简单介绍了Jackson如何序列化带有注解的字段。 本文尝试自己定义一个注解，让Jackson序列化时对标注了该注解的字段进行脱敏。
Jackson中DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT和DeserializationFeature. ACCEPT_EMP
徐小陌的博客
11-03 4498
文章目录DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECTDeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT总结 Jackson使用过程中的一些疑惑和跟踪。 DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT 首先先来看看这个配置项对应的JavaDoc： /** * Feature that can be
Apollo配置中心三：自动添加配置更新listener组件
徐小陌的博客
04-26 3035
本文介绍在《Apollo配置中心二：环境隔离方案》的基础上开发基于注解自动添加配置更新监听器的组件，也是对《Apollo配置中心二：环境隔离方案》第6章的补充。
RocketMQ消费者设置了instanceName属性后消息竟不翼而飞
徐小陌的博客
05-17 2697
文章目录生产者代码(Producer.java)消费者代码(Consumer.java)消费紊乱的情况InstanceNameClientId消费均衡RebalanceImpl.javaAllocateMessageQueueAveragely.java总结 本文介绍RocketMQ使用过程中遇到的一个坑：集群模式下一个机器起了多个消费者导致消费紊乱。下面将项目中遇到的问题简化成官方demo来说明。 生产者代码(Producer.java) /* * Instantiate with
Server-Sent Events 一种轻量级的Push方式
徐小陌的博客
07-31 2676
Server-Sent Events 一种轻量级的Push方式。
"SpringMVC学习笔记：学习路线、源码提取与配置详解
SpringMVC学习笔记，学习路线，详细；SpringMVC详细学习笔记主要包括源码的提取，实例代码的提取，maven的配置，web.xml的配置，以及注解代替配置文件的类的书写方法。本文将对这些内容进行详细介绍。 第1章....
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值