首页  思维导图  详情

框架学习总结

2020-12-11 16:39:01   0  举报





AI智能生成

为你推荐

查看更多



spring、springmvc、mybatis主流框架

Spring

springMVC

SpringBoot

作者其他创作

大纲/内容

spring boot

spring boot入门

1、Spring Boot 自述

① 简介：Spring Boot(英文中是“引导”的意思)，是用来简化Spring应用的搭建到开发的过程。应用开箱即用，只要通过 “just run”（可能是 java -jar 或 tomcat 或 maven插件run 或 shell脚本），就可以启动项目。二者，Spring Boot 只要很少的Spring配置文件（例如那些xml，property）。

② 使用原则：因为“习惯优先于配置”的原则，使得Spring Boot在快速开发应用和微服务架构实践中得到广泛应用。

③ Controller层解释

2. @RequestMapping：提供路由信息，”/“路径的HTTP Request都会被映射到sayHello方法进行处理。

④ 启动应用类解释

1. @SpringBootApplication：Spring Boot 应用的标识

2. Application很简单，一个main函数作为主入口。SpringApplication引导应用，并将Application本身作为参数传递给run方法。具体run方法会启动嵌入式的Tomcat并初始化Spring环境及其各Spring组件。

2、Spring Boot 配置文件

① 自动配置（优先级）

1.命令行参数

2.java:comp/env 里的 JNDI 属性

3.JVM 系统属性

4.操作系统环境变量

5.RandomValuePropertySource 属性类生成的 random.* 属性

6.应用以外的 application.properties（或 yml）文件

7.打包在应用内的 application.properties（或 yml）文件

8.在应用 @Configuration 配置类中，用 @PropertySource 注解声明的属性文件

9.SpringApplication.setDefaultProperties 声明的默认属性

② 自定义属性

a. 编译工程在项目根目录 springboot-learning-example，运行 maven 指令：12cd springboot-learning-examplemvn clean install

在 application.properties 中对应 HomeProperties 对象字段编写属性的 KV 值：## 家乡属性 Devhome.province=ZheJianghome.city=WenLinghome.desc=dev: I'm living in ${home.province} ${home.city}.

③ random.* 属性

1.Spring Boot 通过 RandomValuePropertySource 提供了很多关于随机数的工具类。概括可以生成随机字符串、随机 int 、随机 long、某范围的随机数。

④ 多环境配置

1. 很多场景的配置，比如数据库配置、Redis 配置、注册中心和日志配置等。在不同的环境，我们需要不同的包去运行项目。所以看项目结构，有两个环境的配置：application-dev.properties：开发环境application-prod.properties：生产环境

3.那运行 springboot-properties 工程中 Application 应用启动类，从控制台中可以看出，是加载了 application-dev.properties 的属性输出：

SSH框架

1、 struts

2、spring(同上)

3、hibernate

1.JPA入门的认识

①：JPA 全自动的持久化框架，有3个主要的特点：

A、实现了ORM（对象-关系映射）

B、以OOP的方式操作数据库

C、提供了一种移植性很高的查询语

②JPA是一个规范，主要的产品有

A Hibernate JPA

B Spring JPA

C OpenJPA

D EclipseLink

③创建支持JPA的工程

A: 下载支持JPA的EclipseLink2.5.2（导入离线jar文件）

B: B、自动生成POJO类

C: 导入Hibernate JPA的Maven依赖库

D: 配置核心配置文件persistence.xml

④ JPAdemp 常用的注解

@Entity：：用于将JavaBean标识为POJO

@Table(name = "dept")：用于将POJO和表进行映射

@Id：用于映射表的主键

@Column(name = "dname")：用于映射属性名与字段名

框架学习

SSM框架

Spring

1、基本内容：

（是整个项目中装配bean的大工厂，在配置文件中可以指定使用特定的参数去调用实体类的构造方法来实例化对象。）是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

2、Spring的特征：

A、轻量级

B、容器

C、控制反转（IOC|DI）

D、面向切面（AOP）

3、Spring的7个模块

1.Spring Core：Spring的核心模块，提供了容器的支持

2.Spring AOP：提供了AOP的支持

3.Spring ORM：提供了整合持久化框架的解决方案

4.Spring DAO：对JDBC进行重新封装，并提供DAO的支持

5.Spring Context：提供了对UI、JDNL、EJB、远程访问等技术的支持

6.Spring Web：提供对Web应用的支持

7.Spring Web MVC：是一个Web开发框架，提供了对MVC的支持

4、Spring项目的开发环境

A、创建Maven工程Maven是一个项目管理工具，提供了对第三方依赖的简单管理。

B、将Maven工程转换成Web工程（在project facets中勾选java、javascript、dynamic web moudle）

C、让Maven管理第三方依赖库

D、加入到pom.xml文件中

5、Spring容器的工作原理

A、创建Spring的配置文件：applicationContext.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:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsd"><bean id="stu" class="com.trkj.bean.Student"></bean><bean id="date" class="java.util.Date"></bean></beans>

B、启动Spring容器，容器一启动，对象会自动被创建，并保存在Bean容器中（说明：ClassPathXmlApplicationContext就代表Sping容器）

ApplicationContext ac = newClassPathXmlApplicationContext("applicationContext.xml");

C、从Spring容器中拿取对象

①：根据id读取对象：Student stu = (Student) ac.getBean("stu");

②：根据Class读取对象 Date date = ac.getBean(Date.class);

6、Spring的零配置（注解）

A、配置Spring要扫描的包，只有扫描到的类才有机会被实例化（com.trkj包以及子包中的类都有可能被实例化）

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:context="http://www.springframework.org/schema/context"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsd"><context:component-scan base-package="com.trkj" /></beans>

B、为扫描到的类添加注解

①：@Compontent ：组件，可以表示任意的Bean

②：@Service 业务，一般用于修饰业务类

③：@Controller 控制器，一般用于修饰控制器类

@Controller和@RestController的区别：都是用在Controller层；只是使用@RestController注解Controller，则controller中的方法无法返回jsp页面配置的试图解析器。（TestController即为一个自定类。在该类的前面标记@Controller，该类就成了一个控制器类。在浏览器地址栏中输入http://localhost:8080/hello，即对hello()方法进行调用，前台返回hello.jsp界面）

④：@Repository 持久化，一般用于修饰DAO

7、Spring AOP（面向切面编程是对面向对象的思维方式的有力补充）

1. Spring AOP的原理

②AOP核心思想：使用代理对象将应用程序中的业务逻辑同对其提供的通用服务进行分离，降低各部分之间的耦合度可以动态添加和删除切面上的功能而不影响原来的执行代码

③基本原理

1.Target(目标对象)

一个切面被应用的目标对象. Target必须实现预先定义好的接口或类

2.Advice (通知)

类型：前置通知后置通知\t 最终通知环绕通知异常通知

3.Joinpoint(连接点)

目标对象执行过程中明确的执行点，如方法的调用或特定的异常被抛出等一个连接点通常是目标对象一个方法（还可以是字段或构造函数）

4.Pointcut(切入点)

一系列连接点（Joinpoint）的集合即在哪些目标对象的哪些地方需要注入advice

5.Weave (织入)

Advice被应用至目标对象之上的过程

2. Spring AOP的实现

①AOP实现技术主要有：

AspectJ 一个功能强大的AOP框架 Spring AOP Jboss AOP

②关注点

通用服务（需要添加的功能）如：安全验证，日志记录，事务管理、异常管理

③Spring AOP实现主要方式：

1.1. 基于AspcectJ 使用注解方式

1.22.基于XML pojo风格的Spring _AOP实现

1．需要导入第三方jar包：

aspectjrt.jar aspectjweaver.jarcom.springsource.org.aopalliance-1.0.0.jarcom.springsource.net.sf.cglib-2.2.0.jar

2. spring配置文件加入\t

<aop:aspectj-autoproxy />

④定义切面主要涉及的注释：

@Aspect \t\t\t\t 定义一个切面类@Before \t\t\t定义前置通知 @AfterReturning\t\t定义后置通知\t@After\t\t\t定义最终通知 @Around\t\t定义环绕通知@AfterThrowing\t\t定义异常通知@Pointcut 通过空实现的方法名来定义切入点

8、Spring dao

1.连接池Connection Pool

要避免频繁的对数据库进行连接和关闭，从而提高数据库的访问性能。可以将一定数量的Connection对象创建好之后存储到连接池中，当需要访问数据库时，从连接池中拿取一个Connection对象，用完后再还回连接池中。

2.druid连接池 (由阿里巴巴开发，应用在阿里巴巴600多个项目当中。)

①依赖库： <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.0.22</version> </dependency>

②在applicationContext.xml中配置druid连接池

3.applicationContext.xml 的主要配置：

①连接数据库：

②配置初始大小

③配置获取连接等待超时的时间

④配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒

⑤- 配置一个连接在池中最小生存的时间，单位是毫秒

⑥打开PSCache，并且指定每个连接上PSCache的大小

⑦配置- JdbcTemplate

1）配置过程

2）jdbcTemplate的简介：

Spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。

3）JdbcTemplate主要提供以下五类方法：

1. execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；

2. update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于执行批处理相关语句；(batchUpdate()批量插入、更新和删除方法)

3. query方法及queryForXXX方法：用于执行查询相关语句；

4. call方法：用于执行存储过程、函数相关语句。

4.从Spring容器中获取JdbcTemplate 对象

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");JdbcTemplate jdbc = ac.getBean(JdbcTemplate.class);

5. DAO的主要操作（CURD）

通过继承 JdbcDaoSupport类来获取相关对象、方法。

6.零配置

9、Spring jdbc

完成步骤

1.导入Oracle的驱动包到到WEB-INF/lib目录下

2.导入依赖库

<dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>4.3.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>4.3.2.RELEASE</version></dependency>

3.创建JdbcTemplate，该类提供了一系列的方法来执行sql语句

②//创建JdbcTemplate对象JdbcTemplate jdbc = new JdbcTemplate(dmds);

4.调用JdbcTemplate类提供的方法来执行sql语句

2. 执行insert、update、delete调用update()方法执行select调用query()或queryForObject()方法

10、Spring的反射

1、反射定义：

当JVM加载类到内存后，会自动为该类创建一个Class对象，Class对象中保存了类的信息。

Class对象中保存的信息有：包 Package getPackage()父类 Class getSuperClass()实现的接口 Class[] getInterfaces()属性 Field[] getFields()/getDeclaredFields()方法 Method[] getMethods()/getDeclaredMethods()构造方法 Constructor[] getConstructors()

2、class类：

①如何获取Class对象

1）Class c = Class.forName("java.lang.String");将String类加载到内存，static块会执行，因为类以字符串的形式存在，所以可配置性很强。2）Class c = String.class3）String s = new String();Class c = s.getClass();4）基本类型：Classs c = int.class

②通过Class创建对象

Class c = String.class;Object obj = c.newInstance();//调用无参构造方法

3、通过反射动态访问成员：

①访问属性：

②访问方法：

4、反射的特点：

优点：通过通用的代码大大提高程序的可配置性

缺点：降低性能降低了安全性，违背了OOP的思想

5、反射的综合应用：

自动生成SQL语句

1.Class c = obj.getClass();//1、获取表名String tableName = c.getSimpleName();logger.debug(tableName);

11.Spring-log4j(日志)

1、认识log4j

① log4j是一个日志管理工具，用于输出程序在运行过程中的信息（调试信息、错误信息等等）【four-4---for java---j】

②控制台输出与log4j的比较

System.out.println()：性能较低只能输出到控制台

Log4J：性能较高可以将日志保存到任意地方（控制台、文件、数据库、远程服务器……）可以指定日志输出的格式可以指定日志的输出级别

2、log4j的5个级别：

debug < info < warn < error < fatal输出日志时，如果指定了一个级别，则只会输出大于等于该级别的日志。

3、log4j的3大核心组件

A:Logger（日志）

1）获取Logger对象 private static Logger logger = Logger.getLogger(Demo.class);

2）指定日志级别 logger.setLevel(Level.DEBUG);

3）输出日志 logger.debug("这是调试信息"); logger.info("这是普通信息"); logger.warn("这是警告信息"); logger.error("这是错误信息"); logger.fatal("这是严重错误信息");

B、Appender（追加器）

1） ConsoleAppender：将日志信息输出到控制台

//输出到控制台ConsoleAppender console = new ConsoleAppender(new SimpleLayout());logger.addAppender(console);

2）FileAppender：将日志信息输出到文件

3）RollingFileAppender ：当日志文件达到一定的大小之后，会自动创建新的日志文件

4）DailyRollingFileAppender：每天产生一个新的日志文件

C、Layout（格式）

SimpleLayout：简易格式

4、log4j的占位符

1. %d{yyyy-MM-dd HH:mm:ss} 时间，比如：2018-10-22 20:21:26

2. %L 日志输出的行，比如：30

3. %l 日志输出的位置，比如：com.trkj.log4j.Demo.main(Demo.java:30)

4. %M 日志输出的方法，比如：main

5. %p 日志的级别，比如：ERROR

6. %m 日志的内容

7. %n 换行

用法： PatternLayout pattern = new PatternLayout("%d{yyyy-MM-dd HH:mm:ss}%L %l %M %p %m%n");

5、log4j.properties的注意的问题：

1.文件名是固定的，不能写错

2.位置是固定的，只能放在classpath下，也就是src目录下

3.配置文件

SpringMVC

分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。

2、Spring MVC的工作流程

1）用户向前端控制器DispatcherServlet发送请求

2）由HandlerMapping找到对应的负责处理请求的控制器（Controller）

3）由HandlerAdapter找到对应的方法来处理请求

4）自动进行消息转换、数据类型转换、数据格式化、数据验证之后处理请求

5）返回ModelAndView对象，其中，Model保存了返回的数据，View保存了要跳转的路径

6）由ViewResolver选择合适的视图渲染技术（如JSP）

7）将Model中的数据在页面中显示出来

8）将最终的结果展示给用户

3、Spring MVC 控制器的实现

① Spring MVC 使用@Controller注解定义一个控制器

@Controller注解表明了一个类是作为控制器的角色而存在的。

② Spring MVC 使用@RequestMapping注解映射请求路径

你可以使用@RequestMapping注解来将请求URL，根据特定的HTTP请求方法（“GET”“POST”方法等）、HTTP请求中是否携带特定参数等条件，将请求映射到匹配的方法上。

③ Spring MVC 定义@RequestMapping注解的处理方法

2)使用@RequestBody注解映射请求体方法参数中的@RequestBody注解暗示了方法参数应该被绑定了HTTP请求体的值。

3)使用@ResponseBody注解映射响应体 @ResponseBody注解与@RequestBody注解类似。@ResponseBody注解可被应用于方法上，标志该方法的返回值（更正，原文是return type，看起来应该是返回值）应该被直接写回到HTTP响应体中去

4)使用@RestController注解创建REST控制器不需要在每个@RequestMapping方法上都增加一个@ResponseBody注解，更简明的做法是，给你的控制器加上一个@RestController的注解。

5)对方法使用@ModelAttribute注解

6)在请求之间使用@SessionAttributes注解，使用HTTP会话保存模型数据

7)使用@CookieValue注解映射cookie值

@CookieValue注解能将一个方法参数与一个HTTP cookie的值进行绑定。

8)使用@RequestHeader注解映射请求头属性

④ Spring MVC 处理异步请求

1）异步请求的异常处理

当Callable抛出异常时，Spring MVC会把一个Exception对象分派给Servlet容器进行处理，而不是正常返回方法的返回值

若方法返回的是一个DeferredResult对象，你可以选择调Exception实例的setResult方法还是setErrorResult方法。

2）拦截异步请求

处理器拦截器HandlerInterceptor可以实现AsyncHandlerInterceptor接口拦截异步请求，

3）使用“服务器端事件推送”的HTTP Streaming

“服务器端事件推送”技术正如其名，是用于由服务器端向客户端进行的事件推送。只需要方法返回一个SseEmitter类型的对象即可。

4）直接写回输出流OutputStream的HTTP Streaming

异步请求处理的相关配置：

<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> <filter> <filter-name>Spring OpenEntityManagerInViewFilter</filter-name> <filter-class>org.springframework.~.OpenEntityManagerInViewFilter</filter-class> <async-supported>true</async-supported> </filter> <filter-mapping> <filter-name>Spring OpenEntityManagerInViewFilter</filter-name> <url-pattern>/*</url-pattern> <dispatcher>REQUEST</dispatcher> <dispatcher>ASYNC</dispatcher> </filter-mapping> </web-app>

4、 Spring MVC 处理器映射

Spring MVC 使用HandlerInterceptor拦截请求

处理器映射处理过程配置的拦截器，必须实现 org.springframework.web.servlet包下的 HandlerInterceptor接口。

preHandle(..)，它在处理器实际执行之前会被执行；

postHandle(..)，它在处理器执行完毕以后被执行；

afterCompletion(..)，它在整个请求处理完成之后被执行。

preHandle(..) 方法返回一个boolean值。你可以通过这个方法来决定是否继续执行处理链中的部件。

5、spring mvc的视图解析

1. Spring MVC 使用ViewResolver接口解析视图

①AbstractCachingViewResolver

一个抽象的视图解析器类，提供了缓存视图的功能。通常视图在能够被使用之前需要经过准备。继承这个基类的视图解析器即可以获得缓存视图的能力

②XmlViewResolver

视图解析器接口ViewResolver的一个实现，该类接受一个XML格式的配置文件。该XML文件必须与Spring XML的bean工厂有相同的DTD。默认的配置文件名是/WEB-INF/views.xml。

③ResourceBundleViewResolver

视图解析器接口ViewResolver的一个实现，采用bundle根路径所指定的ResourceBundle中的bean定义作为配置。一般bundle都定义在classpath路径下的一个配置文件中。默认的配置文件名为views.properties。

④UrlBasedViewResolver

ViewResolver接口的一个简单实现。它直接使用URL来解析到逻辑视图名，除此之外不需要其他任何显式的映射声明。如果你的逻辑视图名与你真正的视图资源名是直接对应的，那么这种直接解析的方式就很方便，不需要你再指定额外的映射。

⑤InternalResourceViewResolver

urlBasedViewResolver的一个好用的子类。它支持内部资源视图（具体来说，Servlet和JSP）、以及诸如JstlView和TilesView等类的子类。

⑥VelocityViewResolver / FreeMarkerViewResolver

UrlBasedViewResolver下的实用子类，支持Velocity视图VelocityView（Velocity模板）和FreeMarker视图FreeMarkerView以及它们对应子类。

⑦ContentNegotiatingViewResolver

视图解析器接口ViewResolver的一个实现，它会根据所请求的文件名或请求的Accept头来解析一个视图。

2. Spring MVC 视图链

Spring支持同时使用多个视图解析器。因此，你可以配置一个解析器链，并做更多的事比如，在特定条件下覆写一个视图等。

1. 配置文件：<bean id="excelViewResolver" class="org.springframework.web.servlet.view.XmlViewResolver"> <property name="order" value="1"/> <property name="location" value="/WEB-INF/views.xml"/></bean>

2. 需要指定它们的次序，那么设置order属性即可。请记住，order属性的值越大，该视图解析器在链中的位置就越靠后。

3. Spring MVC 视图重定向

① 重定向视图 RedirectView

使得DispatcherServlet放弃使用一般的视图解析机制，因为你已经返回一个（重定向）视图给DispatcherServlet了，所以它会构造一个视图来满足渲染的需求。

② 向重定向目标传递数据

1） @RequestMapping方法可以声明一个RedirectAttributes类型的方法参数，用它来指定专门供重定向视图RedirectView取用的属性。如果重定向成功发生，那么RedirectAttributes对象中的内容就会被使用；否则则使用模型model中的数据。

2） FlashMap被用来存储flash属性，而用FlashMapManager来存储、取回、管理FlashMap的实例。

4. Spring MVC 提供地区信息

① Spring MVC 获取时区信息

1）LocaleContextResolver接口为LocaleResolver提供了拓展点，允许解析器在LocaleContext中提供更多的信息，这里面就可以包含时区信息。

2）通过RequestContext.getTimeZone()方法获得。时区信息会自动被SpringConversionService下注册的日期/时间转换器Converter及格式化对象Formatter所使用。

② Spring MVC 了解Accept请求头解析器

AcceptHeaderLocaleResolver解析器会检查客户端（比如，浏览器，等）所发送的请求中是否携带accept-language请求头。

③ Spring MVC 了解Cookie解析器

CookieLocaleResolver解析会检查客户端是否有Cookie，里面可能存放了地区Locale或时区TimeZone信息。

CookieLocaleResolver支持的属性

cookieName：cookie名

cookieMaxAge：cookie被保存在客户端的最长时间。如果该值为-1，那么cookie将不会被持久化，在客户端浏览器关闭之后就失效了

cookiePath：限制了cookie仅对站点下的某些特定路径可见。如果指定了cookiePath，那么cookie将仅对该路径及其子路径下的所有站点可见

5. Spring MVC 了解Session解析器

SessionLocaleResolver允许你从session中取得可能与用户请求相关联的地区Locale和时区TimeZone信息。这些设置仅会为该会话（session）临时保存，session结束后，这些设置就会失效。

6. Spring MVC 了解地区更改拦截器

通过调用LocaleResolver的setLocale()方法来更改地区。

6、Spring MVC 提供multipart（文件上传）支持

1. Spring MVC 文件上传概述

① Spring内置对多路上传的支持，专门用于处理web应用中的文件上传。

② 想启用Spring的多路上传支持，你需要在web应用的上下文中添加一个多路传输解析器。

2. Spring MVC 使用MultipartResolver与Commons FileUpload传输文件

① 要让多路解析器正常工作，你需要在classpath路径下准备必须的jar包。如果使用的是通用的多路上传解析器CommonsMultipartResolver，你所需要的jar包是commons-fileupload.jar。

② 解析器会把当前的HttpServletRequest请求对象包装成一个支持多路文件上传的请求对象MultipartHttpServletRequest。有了MultipartHttpServletRequest对象，你不仅可以获取该多路请求中的信息，还可以在你的控制器中获得该多路请求的内容本身。

配置文件：<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">  <property name="maxUploadSize" value="100000"/></bean>

3. Spring MVC 处理Servlet 3.0下的MultipartResolver

当你通过以上任一种方式启用了Servlet 3.0多路传输转换功能，你就可以把一个StandardServletMultipartResolver解析器添加到你的Spring配置中去了：

配置文件：<bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver"></bean>

4. Spring MVC 处理表单中的文件上传

步骤一：创建一个接受文件上传的表单将允许用于直接上传整个表单。编码属性（enctype="multipart/form-data"）能让浏览器知道如何对多路上传请求的表单进行编码（encode）。

步骤二：创建一个能处理文件上传的控制器。这里需要的控制器与一般注解了@Controller的控制器基本一样，除了它接受的方法参数类型是MultipartHttpServletRequest，或MultipartFile。@Controller

5. Spring MVC 处理客户端发起的文件上传请求

7、 Spring MVC 异常处理

MyBatis

是一个支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

2、MyBatis 的入门介绍

1.所要做的

①MyBatis做的：对象关系映射、DAO

②我们要做的：写SQL语句

2.MyBatis的特点

①优点：1、简单易学 2、灵活 3、解除sql与程序代码的耦合 4、提供映射标签，支持对象与数据库的orm字段关系映射 5、提供对象关系映射标签，支持对象关系组建维护 6、提供xml标签，支持编写动态sql。

②缺点： 1、编写SQL语句时工作量很大，尤其是字段多、关联表多时，更是如此。 2、SQL语句依赖于数据库，导致数据库移植性差，不能更换数据库。 3、框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。 4、二级缓存机制不佳

3.Mybatis工作原理

①加载mybatis全局配置文件（数据源、mapper映射文件等），解析配置文件，MyBatis基于XML配置文件生成Configuration，和一个个MappedStatement（包括了参数映射配置、动态SQL语句、结果映射配置），其对应着<select | update | delete | insert>标签项。

②SqlSessionFactoryBuilder通过Configuration对象生成SqlSessionFactory，用来开启SqlSession。

③SqlSession对象完成和数据库的交互：

a、用户程序调用mybatis接口层api（即Mapper接口中的方法）

b、SqlSession通过调用api的Statement ID找到对应的MappedStatement对象

c、通过Executor（负责动态SQL的生成和查询缓存的维护）将MappedStatement对象进行解析，sql参数转化、动态sql拼接，生成jdbc Statement对象

d、JDBC执行sql。

e、借助MappedStatement中的结果映射关系，将返回结果转化成HashMap、JavaBean等存储结构并返回。

4.Mybatis执行流程

A、映射文件用于定义表的crud等sql语句，每一个表都必须定义一个映射文件；

B、配置文件配置数据库的连接信息（驱动类、url、登陆名、密码）MyBatis的属性注册映射文件

C、Configuration类负责读取配置文件

D、SqlSessionFacotry负责创建SqlSession对象的工厂

E、SqlSession负责执行SQL语句

F、Transaction负责事务的提交和回滚

5.MyBatis实践

① 添加Maven依赖库

② 定义核心配置文件（放在src/main/resources目录下）

(加入到配置文件中)<mappers><mapper resource="Mappers/Dept_Mapper.xml"></mapper></mappers>

③根据相应的要求与业务配置mapper等映射文件

3、mybatis 的动态sql

1.逻辑标签

简单的条件判断，利用if语句我们可以实现某些简单的条件选择

select * from dept where 1 = 1<if test="deptno != null">and DEPTNO = #{deptno}</if>

choose

相当于多重if，通常都是与when和otherwise搭配使用当when中有条件满足的时候，就会跳出choose，即所有的when和otherwise条件中，只有一个会输出

<when test="deptno != null">DEPTNO = #{deptno}</when><when test="dname != null and dname.length != 0">DNAME = #{dname}</when><otherwise>LOC = #{loc}</otherwise>

foreach

主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合

collection 表示一个集合

如果传入的是单参数且参数类型是一个List的时候，collection属性值为list

如果传入的是单参数且参数类型是一个array数组的时候，collection的属性值为array

item 表示集合中每一个元素进行迭代时的别名，必须指定

index 指定一个名字，用于表示在迭代过程中，每次迭代到的位置

open 表示该语句以什么开始

separator 表示在每次进行迭代之间以什么符号作为分隔符

close 表示以什么结束

2.功能标签

where

生成一个where子句，能够做一些智能的判断。会在写入where元素的地方输出一个where不需要考虑where元素里面的条件输出是什么样子的，MyBatis会处理忽略首个and或者or不需要考虑空格的问题

<where><if test="deptno != null">and DEPTNO = #{deptno}</if><if test="loc != null and loc.length != 0">and LOC = #{loc}</if></where>

trim

trim是where的加强版本，where是trim的简化版本.可以在自己包含的内容前加上某些前缀，也可以在其后加上某些后缀与之对应的属性是prefix和suffix可以把包含内容的首部某些内容覆盖，也可以把尾部的某些内容覆盖（即忽略）对应的属性是prefixOverrides和suffixOverrides

<trim prefix="where" prefixOverrides="and|or"><if test="deptno != null">and DEPTNO = #{deptno}</if><if test="dname != null and dname.length != 0">and DNAME = #{dname}</if><if test="loc != null and loc.length != 0">and LOC = #{loc}</if></trim>

set

主要用在update操作的时候输出set如果包含的语句是以逗号结束的话将会把该逗号忽略set可以动态的更新那些修改了的字段

4、mybatis 的关系查询

1.解决表的字段名和pojo的属性名不同时的问题

2.类与类之间建立关系

一对一

class A{B b;}class B{A a;}

一对多

A:B -> 1:Nclass A{List<B> b;}class B{A a;}

多对多

class A{List<B> b;}class B{List<A> a;}

3.类与类关系具体实践方法