Spring Boot 学习笔记（spring boot基础教程）

　　本篇文章为你整理了Spring Boot 学习笔记（spring boot基础教程）的详细内容，包含有spring boot 教程 spring boot基础教程 spring boot 怎么学 spring boot教学 Spring Boot 学习笔记，希望能帮助你了解 Spring Boot 学习笔记。

　　使用 java 类作为 xml 配置文件的替代，是配置 spring 容器的纯 java 的方式。

　　在这个 java 类中可以创建 java 对象，把对象放入 spring 容器中（注入到容器）。

　　对于此JavaConfig相关的示例创建的是普通的Java项目，并非SpringBoot项目！

　　@Configuration

　　放在类的上面，表示此类作为配置文件使用，相当于一个配置类

　　@Bean

　　放在配置类中的方法上面，用来声明对象，将对象注入到容器中

　　方法返回值需要是注入的对象类型

　　若没有配置@Bean中的 name 属性，则从容器中获取该对象需要用其方法名

　　若配置了@Bean中的 name 属性，则从容器中获取该对象需要用配置的 name 名称

　　需要使用到两个注解：

　　@Configuration：放在一个类的上面，表示这个类是作为配置文件使用的。

　　@Bean：放在配置类中的方法上，声明对象，把对象注入到容器中。

　　配置类示例：

/**

　　 * Configuration:表示当前类是作为配置文件使用的。就是用来配置容器的

　　 * 位置：在类的上面

　　 * SpringConfig这个类就相当于beans.xml

　　@Configuration

　　public class SpringConfig {

　　 * 创建方法，方法的返回值是对象。在方法的上面加入@Bean

　　 * 方法的返回值对象就注入到容器中。

　　 * @Bean: 把对象注入到spring容器中。作用相当于 bean

　　 * 位置：方法的上面

　　 * 说明：@Bean,不指定对象的名称，默认是方法名是 id

　　 @Bean

　　 public Student createStudent(){

　　 Student s1 = new Student();

　　 s1.setName("张三");

　　 s1.setAge(26);

　　 s1.setSex("男");

　　 return s1;

　　 /***

　　 * 指定对象在容器中的名称（指定 bean 的id属性）

　　 * @Bean的name属性，指定对象的名称（id）

　　 @Bean(name = "lisiStudent")

　　 public Student makeStudent(){

　　 Student s2 = new Student();

　　 s2.setName("李四");

　　 s2.setAge(22);

　　 s2.setSex("男");

　　 return s2;

　　测试：

public class MyTest {

　　 @Test

　　 public void test01() {

　　 // 使用配置文件方式声明的bean，需要用 ClassPathXmlApplicationContext，参数传配置文件路径

　　 ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

　　 Student student = (Student) context.getBean("myStudent");

　　 System.out.println(student);

　　 @Test

　　 public void test02() {

　　 // 使用配置类方式将对象注入到容器，需要使用 AnnotationConfigApplicationContext，参数传配置类的class

　　 ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

　　 // 配置类中方法的Bean设置name属性，则通过name属性名获取对象；否则默认可通过其方法名获取

　　 Student s = (Student) ctx.getBean("lisiStudent");

　　 // Student s = (Student) ctx.getBean("makeStudent");

　　 // Student s = (Student) ctx.getBean("createStudent");

　　 System.out.println(s);

　　小结：

　　使用配置类的方式，需要在配置类上使用@Configuration；需要在配置类中的方法上使用@Bean声明对象，将对象注入到容器中。

　　配置类中的方法返回值类型是需要注入的对象类型；若未配置@Bean中的 name 属性，则获取该对象时需要使用方法名获取；若配置了@Bean中的 name 属性，则通过配置的 name 名称获取该对象。

　　创建容器对象时，不再使用ClassPathXmlApplicationContext接口实现类，不再通过配置文件来注入到容器对象中；而是使用AnnotationConfigApplicationContext接口实现类，通过配置类的 class 来将对象注入到容器。

　　@ImportResource

　　使用在配置类的上面

　　作用是导入其他的 xml 配置文件，等于在 xml 中使用 import resources="其他配置文件"/

　　需要在 value 属性中指定配置文件的路径

@Configuration

　　@ImportResource(value = "classpath:applicationContext.xml")

　　public class SpringConfig {

　　@PropertySource

　　使用在配置类的上面

　　用来读取 properties 属性配置文件

　　使用属性配置文件可以实现外部化配置，在程序代码之外提供数据。

　　@ComponentScan：使用在配置类上，扫描指定包中注解，来创建对象以及给属性赋值

　　示例：

--配置类--

　　@Configuration

　　@ImportResource(value = "classpath:applicationContext.xml") // 导入xml配置文件

　　@PropertySource(value = "classpath:config.properties") // 读取属性配置文件

　　@ComponentScan(basePackages = "com.luis.vo") // 声明组件扫描器，扫描指定包中的注解

　　public class SpringConfig {

　　--config.properties--

　　tiger.name=东北虎

　　tiger.age=3

　　--vo数据类--

　　@Component("tiger")

　　public class Tiger {

　　 @Value("${tiger.name}")

　　 private String name;

　　 @Value("${tiger.age}")

　　 private Integer age;

　　--测试--

　　@Test

　　public void test04() {

　　 ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

　　 Tiger tiger = (Tiger) ctx.getBean("tiger");

　　 System.out.println(tiger);

　　SpringBoot 入门

　　SpringBoot 是 Spring 中的一个成员，可简化 Spring，SpringMVC 的使用。

　　其核心还是 IOC 容器。

　　SpringBoot 特点

　　
其自动配置在主类之上，每个 SpringBoot 项目都会有一个主类

@SpringBootApplication

　　public class SpringbootTest03Application {

　　 public static void main(String[] args) {

　　 SpringApplication.run(SpringbootTest03Application.class, args);

　　
是一个复合注解，包含以下三个注解（以下注解的功能其全具备）

　　@SpringBootConfiguration ----- 该注解标注的类可当做配置类使用

　　@EnableAutoConfiguration ----- 启用自动配置，将常用框架以及第三方对象创建好

　　@ComponentScan ----- 可扫描到该注解标注的类的包及其子包下其他注解

　　1.@SpringBootConfiguration

　　@Configuration

　　public @interface SpringBootConfiguration {

　　 @AliasFor(

　　 annotation = Configuration.class

　　 boolean proxyBeanMethods() default true;

　　说明：使用了@SpringBootConfiguration注解标注的类，可以作为配置文件使用，

　　可以使用@Bean声明对象，注入到容器，

　　故主类可作为一个配置类使用，在其类中可在方法上使用@Bean声明对象

　　2.@EnableAutoConfiguration

　　启用自动配置，把java对象配置好，注入到spring容器中；例如可以把mybatis的对象创建好，放入到容器中。

　　3.@ComponentScan

　　扫描器，找到注解，根据注解的功能创建对象，给属性赋值等。

　　默认扫描的包： @ComponentScan所标注的类所在的包和子包。

　　SpringBoot 的配置文件

　　避免中文乱码，需要在 IDEA 中设置 encoding 为 UTF-8

　　配置文件名： application

　　扩展名有：properties( k=v) 以及 yml ( k: v)

　　可使用 application.properties，application.yml 两种文件格式

　　创建 SpringBoot 项目时默认创建的是 application.properties 配置文件格式

　　以下为配置示例：

　　例1：application.properties 中设置端口和上下文

# 设置端口

　　server.port=8888

　　# 设置访问应用的上下文路径

　　server.servlet.context-path=/myWeb

　　例2：application.yml 中设置端口和上下文（推荐使用）

　　这种格式的配置文件，结构比较清晰

　　注意：value 值前有一个空格

server:

　　 port: 8083

　　 servlet:

　　 context-path: /myboot

　　注意：如果同时存在两种格式的配置文件，即 application.properties 和 application.yml 两个配置文件同时存在，则默认使用 application.properties 这种格式中的配置！

　　多环境配置的应用

　　有开发环境，测试环境，上线的环境。

　　每种环境有不同的配置信息，例如端口，上下文访问路径，数据库 url，用户名，密码等，所以需要多种环境配置。

　　使用多环境配置文件，可以方便的切换不同的配置。

　　多环境配置方式：

　　
创建多个配置文件，文件命名规则：application-环境名称.properties(yml)【一般环境名使用 dev/test/online 这几种】

　　创建开发环境的配置文件：application-dev.yml

#项目开发使用的环境

　　server:

　　 port: 8080

　　 servlet:

　　 context-path: /mydev

　　创建测试环境的配置文件：application-test.yml

#项目测试使用的环境

　　server:

　　 port: 8081

　　 servlet:

　　 context-path: /mytest

　　创建上线环境的配置文件：application-online.yml

#项目上线使用的环境

　　server:

　　 port: 8082

　　 servlet:

　　 context-path: /myonline

　　
在主配置文件 application.yml 中激活要使用的环境【激活的配置信息是根据多环境文件的命名来确定】

　　主配置文件中激活要使用的环境：application.yml

#激活使用的环境

　　spring:

　　 profiles:

　　 active: online

　　
使用 @Value 读取配置文件数据

　　我们可以在主配置文件中使用 key-value 键值对的格式进行数据的配置；

　　因为主配置文件已经由 Spring 自动管理，所以可以直接在自己写的控制器类的属性上通过 @Value("${server.port}")读取配置文件中数据，并对属性进行赋值。

@Controller

　　public class MyController {

　　 @Value("${server.port}")

　　 private Integer port;

　　 @Value("${server.servlet.context-path}")

　　 private String contextPath;

　　 @Value("${project.name}")

　　 private String projectName;

　　 @Value("${project.dev}")

　　 private String projectDev;

　　 @RequestMapping("/data")

　　 @ResponseBody

　　 public String queryData() {

　　 return port + "======== port " + contextPath + "======== contextPath "

　　 + projectName + "======== projectName " + projectDev + "======== projectDev";

　　@ConfigurationProperties

　　使用位置：类的上面

　　作用：把配置文件中符合条件的数据映射为 java 对象

　　需要配置其 prefix 属性：即配置文件中的某些 key 开头的内容

　　使用示例：@ConfigurationProperties(prefix = "school")

　　使用解释：类上添加@ConfigurationProperties注解后，其将从属性配置文件中找以配置的 prefix 属性值，即school开头的配置，将所有 school后面的配置参数与该类中的所有属性相比较，如果匹配成功，则将配置文件中配置的对应的数据赋值给该类中同名属性，完成数据映射。

　　使用示例：

访问：http://localhost:8888/myboot/info

　　结果：info = SchoolInfo{name=哈师大, addr=东北, level=2}

　　
SpringBoot 默认不支持 JSP，需要进行相关配置才能使用 JSP。

　　JSP 技术慢慢被淘汰，有更好的技术替代它。

　　使用 SpringBoot 框架时不推荐使用 JSP，后面将使用 Thymeleaf 模板技术完全替代 JSP！

　　使用步骤：

　　
添加一个处理 JSP 的依赖，负责编译 JSP 文件（如果需要使用 servlet jsp jstl 功能则需要另外加对应依赖）

 !--处理JSP的依赖--

　　 dependency

　　 groupId org.apache.tomcat.embed /groupId

　　 artifactId tomcat-embed-jasper /artifactId

　　 /dependency

　　 dependency

　　 groupId javax.servlet /groupId

　　 artifactId jstl /artifactId

　　 /dependency

　　 dependency

　　 groupId javax.servlet /groupId

　　 artifactId javax.servlet-api /artifactId

　　 /dependency

　　 dependency

　　 groupId javax.servlet.jsp /groupId

　　 artifactId javax.servlet.jsp-api /artifactId

　　 version 2.3.1 /version

　　 /dependency

　　
在 main 目录下创建一个名为 webapp 的目录（名称固定）；在项目工程结构中设置该目录为 web 资源目录（进入项目结构设置后，点击 Web 选项，从 Web Resource Directories 下添加新创建的 webapp 目录为 web 资源目录即可）

　　
在 webapp 目录下新建 index.jsp 用来显示 controller 中的数据

 %@ page contentType="text/html;charset=UTF-8" language="java" %

　　 html

　　 head

　　 title jsp /title

　　 /head

　　 body

　　 SpringBoot中使用JSP显示数据：${data}

　　 /body

　　 /html

　　
public String doJsp(Model model) {

　　 // 将数据放到request中（与request.setAttribute作用相同）

　　 model.addAttribute("data", "SpringBoot使用JSP");

　　 return "index";

　　
原因：因为 SpringBoot 使用的是内嵌的 Tomcat

　　SpringBoot 使用容器 ApplicationContext

　　使用场景：不想启动整个项目，只想测试某个功能，就可直接通过run方法获取容器对象，通过容器对象进行相关测试。

　　如果想通过代码，从容器中获取对象：

　　通过SpringApplication.run(Application.class, args); 其返回值即可获取容器对象。

　　SpringApplication.run(SpringbootUseJspApplication.class, args)返回的就是一个 ApplicationContext 容器对象！

解析：SpringApplication.run(SpringbootUseJspApplication.class, args);

　　点进其run方法：

　　public static ConfigurableApplicationContext run(Class ? primarySource, String... args) {

　　 return run(new Class[]{primarySource}, args);

　　查看ConfigurableApplicationContext类：

　　public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {...}

　　总结：通过run方法获取的是容器对象ApplicationContext的子类，即也是一个容器对象。

　　容器使用示例：

　　
// 直接通过run方法获取容器对象

　　 ApplicationContext ctx = SpringApplication.run(SpringbootUseContainerApplication.class, args);

　　 // 从容器中获取指定对象

　　 UserService userService = (UserService) ctx.getBean("userService");

　　 // 调用对象的方法进行测试

　　 userService.sayHello("luis");

　　
介绍：这两个接口都有一个 run 方法。

　　执行时机：容器对象创建好后自动会执行接口中的 run() 方法

　　使用场景：需要在容器启动后执行一些内容，比如读取配置文件，数据库连接之类的。

　　使用方式：实现接口，重写 run 方法，方法中写需要在容器启动后待执行的内容。

@FunctionalInterface

　　public interface CommandLineRunner {

　　 void run(String... args) throws Exception;

　　@FunctionalInterface

　　public interface ApplicationRunner {

　　 void run(ApplicationArguments args) throws Exception;

　　使用示例：（以下以实现 CommandLineRunner接口为例）

　　
让启动类实现 CommandLineRunner接口，重写 run 方法进行测试

@SpringBootApplication

　　public class SpringbootRunApplication implements CommandLineRunner {

　　 @Resource

　　 private UserService userService;

　　 public static void main(String[] args) {

　　 System.out.println("main start");

　　 // 创建容器对象

　　 SpringApplication.run(SpringbootRunApplication.class, args);

　　 System.out.println("main end");

　　 @Override

　　 public void run(String... args) throws Exception {

　　 System.out.println("容器对象创建后执行此run方法");

　　 // 此方法在容器对象创建后自动执行

　　 // 可在此调用容器对象中的方法

　　 userService.sayHello("jack");

　　
拦截器是 SpringMVC 中的一种对象，能拦截对 Controller 的请求。

　　在框架中有系统实现好的拦截器，也可以自定义拦截器，实现对请求的预先处理。

　　回顾 SpringMVC 中使用拦截器

　　
创建类实现 SpringMVC 框架的 HandlerInterceptor 接口，重写对应的方法

public interface HandlerInterceptor {

　　 default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

　　 return true;

　　 default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {

　　 default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {

　　
创建拦截器类，实现 HandlerInterceptor接口，重写相关方法

public class LoginInterceptor implements HandlerInterceptor {

　　 @Override

　　 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

　　 System.out.println("执行LoginInterceptor拦截器类的preHandle方法");

　　 return true;

　　
创建自定义配置类实现 WebMvcConfigurer接口，重写addInterceptors接口方法，在此方法中进行拦截器的相关配置（注入拦截器对象，指定拦截地址等）

@Configuration // 成为配置类=====

　　public class MyAppConfig implements WebMvcConfigurer {

　　 // 重写addInterceptors方法，添加拦截器对象，注入到容器中

　　 @Override

　　 public void addInterceptors(InterceptorRegistry registry) {

　　 // 创建拦截器对象

　　 HandlerInterceptor loginInterceptor = new LoginInterceptor();

　　 // 指定拦截的请求URI地址

　　 String[] path = {"/user/**"};

　　 // 指定不拦截的URI地址

　　 String[] excludePath = {"/user/login"};

　　 // 添加拦截器对象，指定拦截以及不拦截的URI地址

　　 registry.addInterceptor(loginInterceptor)

　　 .addPathPatterns(path)

　　 .excludePathPatterns(excludePath);

　　
访问的测试结果：

　　访问http://localhost:8080/user/account时，后台有拦截器拦截信息输出【此请求走拦截器，被拦截器拦截】

　　访问http://localhost:8080/user/login时，后台无拦截器拦截信息输出【此请求不走拦截器，不会被拦截器拦截】

　　
创建 servlet 类，继承 HttpServlet，重写相关方法

public class MyServlet extends HttpServlet {

　　 // 直接重写service方法，则doGet和doPost请求都直接走此方法

　　 @Override

　　 protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

　　 // 设置字符编码

　　 response.setContentType("text/html;charset=UTF-8");

　　 // 使用应答对象HttpServletResponse，输出应答结果

　　 PrintWriter out = response.getWriter();

　　 out.print("SpringBoot中使用Servlet");

　　 out.flush();

　　 out.close();

　　
创建自定义配置类，在类中定义指定返回值类型的方法，注册 Servlet 对象

@Configuration

　　public class WebApplicationConfig {

　　 // ====定义指定返回值类型的方法，注册servlet对象====

　　 @Bean

　　 public ServletRegistrationBean servletRegistrationBean() {

　　 // 两种方式注册servlet：

　　 // 方式一：使用ServletRegistrationBean对象的有参构造

　　 // 下列对象构造方法参数：第一个是需要注册的servlet对象，第二个是对应servlet的访问地址

　　 // ServletRegistrationBean bean = new ServletRegistrationBean(new MyServlet(), "/login1", "/login2");

　　 // 方式二：使用ServletRegistrationBean对象的无参构造

　　 ServletRegistrationBean bean = new ServletRegistrationBean();

　　 bean.setServlet(new MyServlet());

　　 bean.addUrlMappings("/login3", "/login4");

　　 return bean;

　　
Filter 是 Servlet 规范中的过滤器，可以处理请求，对请求的参数，属性进行调整。

　　常常在过滤器中处理字符编码。

　　SpringBoot 中使用过滤器 Filter：

　　使用步骤：

　　
创建自定义的过滤器类，实现 javax.servlet.Filter 接口，重写 doFilter 方法（注意实现的是 servlet 中的 Filter 接口）

public class MyFilter implements Filter {

　　 @Override

　　 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

　　 System.out.println("执行自定义过滤器类MyFilter中的doFilter方法");

　　 // 放行

　　 filterChain.doFilter(servletRequest, servletResponse);

　　
创建自定义配置类，在类中定义指定返回值类型的方法，注册过滤器对象

@Configuration

　　public class WebApplicationConfig {

　　 @Bean

　　 public FilterRegistrationBean filterRegistrationBean() {

　　 // 注册自定义过滤器类，并指定过滤的地址

　　 FilterRegistrationBean bean = new FilterRegistrationBean();

　　 bean.setFilter(new MyFilter());

　　 bean.addUrlPatterns("/user/*");

　　 return bean;

　　
SpringBoot 中使用字符集过滤器

　　一般，都是使用字符集过滤器 CharacterEncodingFilter解决 post 请求中文乱码的问题。

　　CharacterEncodingFilter : 解决 post 请求中文乱码的问题。

　　在 SpringMVC 框架，需要在 web.xml 注册过滤器并配置其相关属性。

　　在SpringBoot 中使用字符集过滤器解决 post 请求乱码有两种方式：

　　使用示例：

　　
@Override

　　 protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

　　 response.setContentType("text/html"); // 此处并没有设置字符编码方式

　　 PrintWriter out = response.getWriter();

　　 out.write("没有设置编码方式，默认使用ISO-8859-1，会出现中文乱码");

　　 out.flush();

　　 out.close();

　　
ServletRegistrationBean bean = new ServletRegistrationBean();

　　 bean.setServlet(new MyServlet());

　　 bean.addUrlMappings("/myservlet");

　　 return bean;

　　
不仅需要在配置类中注册字符集过滤器类，设置字符编码，还需在配置文件中关闭默认启用的过滤器。

　　
在自定义配置类中需创建指定返回值类型的方法，注册 CharacterEncodingFilter字符集过滤器类，设置字符编码

@Configuration

　　public class WebSystemConfig {

　　 // 注册servlet，设置访问路径

　　 @Bean

　　 public ServletRegistrationBean servletRegistrationBean() {

　　 ServletRegistrationBean bean = new ServletRegistrationBean();

　　 bean.setServlet(new MyServlet());

　　 bean.addUrlMappings("/myservlet");

　　 return bean;

　　 // ==================================================================

　　 // 注册CharacterEncodingFilter，并设置字符编码方式

　　 @Bean

　　 public FilterRegistrationBean filterRegistrationBean() {

　　 FilterRegistrationBean reg = new FilterRegistrationBean();

　　 CharacterEncodingFilter filter = new CharacterEncodingFilter();

　　 // 设置字符编码方式

　　 filter.setEncoding("UTF-8");

　　 // 指定request，response都使用encoding的值

　　 filter.setForceEncoding(true);

　　 reg.setFilter(filter); // 注册字符集过滤器对象CharacterEncodingFilter

　　 reg.addUrlPatterns("/*"); // 设置过滤地址

　　 return reg;

　　 // ==================================================================

　　
修改 application.properties 文件，让自定义的过滤器起作用

#SpringBoot中默认已经配置了CharacterEncodingFilter。 编码默认ISO-8859-1

　　#设置enabled=false 作用是关闭系统中配置好的过滤器，使用自定义的CharacterEncodingFilter

　　server.servlet.encoding.enabled=false

#让系统的CharacterEncdoingFilter生效（默认为true）

　　server.servlet.encoding.enabled=true

　　#指定使用的编码方式

　　server.servlet.encoding.charset=UTF-8

　　#强制request，response都使用charset属性的值

　　server.servlet.encoding.force=true

　　ORM 操作 MySQL

　　ORM 是“对象-关系-映射”的简称。（Object Relational Mapping，简称ORM）

　　使用 MyBatis 框架操作 MySQL。

　　使用 MyBatis 框架操作数据，使用 SpringBoot 框架集成 MyBatis。

　　SpringBoot 集成 Mybatis

　　以下是集成步骤示例，创建 dao 接口的代理对象有好几种方式可供选择，以下方式并不完美，注意后续自己修改！

前期准备

　　数据库名：springdb

　　数据库表：student

　　字段：id (int auto_increment) name(varchar) age(int)

　　步骤：

　　
创建 SpringBoot 项目，添加 Spring Web、MyBatis、MySQL 依赖，整理项目目录和 pom 文件，刷新 pom

　　
此处 dao 接口上使用了 @Mapper注解，告诉MyBatis这是 dao 接口，创建此接口的代理对象

@Mapper // 告诉MyBatis这是dao接口，创建此接口的代理对象

　　public interface StudentDao {

　　 Student selectById(@Param("stuId") Integer id);

 ?xml version="1.0" encoding="UTF-8" ?

　　 !DOCTYPE mapper

　　 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

　　 "http://mybatis.org/dtd/mybatis-3-mapper.dtd"

　　 mapper namespace="com.luis.dao.StudentDao"

　　 select id="selectById" resultType="com.luis.model.Student"

　　 select id,name,age from student where id=#{stuId}

　　 /select

　　 /mapper

　　
public String queryStudentById(Integer id) {

　　 Student student = studentService.queryStudentById(id);

　　 return student.toString();

　　
在 pom 文件的 build 标签下添加 mapper 文件的 resources 插件

 !-- resources插件，将mapper文件复制到classes目录下 --

　　 resources

　　 resource

　　 directory src/main/java /directory

　　 includes

　　 include **/*.xml /include

　　 /includes

　　 /resource

　　
#配置数据库连接信息注意mysql新旧版本配置不同

　　spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

　　spring.datasource.url=jdbc:mysql://localhost:3306/springdb?useUnicode=true characterEncoding=UTF-8 serverTimezone=GMT%2B8

　　spring.datasource.username=root

　　spring.datasource.password=luis

　　
运行启动类，输入访问地址测试【注意：填的id必须数据库中有，否则会出现空指针异常】

http://localhost:8888/orm/student/queryById?id=29

　　
在主配置文件中配置 mybatis 日志：（可选不同的日志打印，如选 log4j 这种的，则另需添加相关依赖）

# 日志配置

　　mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

　　第一种方式：使用@Mapper（不建议）

　　使用在类上

　　作用：告诉 MyBatis 这是 dao 接口，会自动创建此接口的代理对象

　　缺点：每一个需要创建代理对象的 dao 接口都需要加上该注解，dao 接口多的时候不方便！

　　示例：

@Mapper // 告诉MyBatis这是dao接口，创建此接口的代理对象

　　public interface StudentDao {

　　 Student selectById(@Param("stuId") Integer id);

　　第二种方式：使用@MapperScan

　　通常使用在主启动类上

　　basePackages属性：通常配置 dao 接口所在包名

　　作用：找到 Dao 接口以及 Mapper 文件（可直接扫描到该包下所有的 dao 接口和 mapper 文件）

　　优点：使用该注解直接扫描指定包，不用在每一个 dao 接口上分别加 @Mapper注解

　　示例：

@SpringBootApplication

　　@MapperScan(basePackages = "com.luis.dao") // 扫描指定包，找到dao接口和mapper文件，mybatis自动创建接口的代理对象

　　public class SpringbootMapperApplication {

　　 public static void main(String[] args) {

　　 SpringApplication.run(SpringbootMapperApplication.class, args);

　　第三种方式：Mapper文件和Dao接口分开管理（开发常用，推荐使用）

　　之前我们的 dao 目录下既有 Java 文件，也有 xml/mapper 文件；如果希望 Java 目录下只有 Java 文件，将 xml/mapper 文件放到 resources 下分开管理，那么只使用之前的 @MapperScan注解是扫描不到 resources 下的 Mapper 文件的，此时我们就需要在配置文件中指定 Mapper 文件的位置。

　　示例：

　　操作：在 resources 下创建子目录（自定义的），例如 mapper，用来存放 mapper 映射文件，将之前 dao 下的 mapper 文件全剪切到 mapper 目录下。

　　同样，我们仍然需要在主启动类上使用 @MapperScan注解指定 dao 所在的包，扫描 dao 接口：

@SpringBootApplication

　　@MapperScan(basePackages = "com.luis.dao") // 扫描指定包，找到dao接口和mapper文件，mybatis自动创建接口的代理对象

　　public class SpringbootMapperApplication {

　　 public static void main(String[] args) {

　　 SpringApplication.run(SpringbootMapperApplication.class, args);

　　在主配置文件中指定 mapper 映射文件的位置：

#指定mapper文件的位置

　　mybatis.mapper-locations=classpath:mapper/*.xml

　　配置资源插件，确保资源文件编译到 classes 目录下：

 !-- resources插件，将所有资源文件复制到classes目录下【配置在pom.xml的build标签下】 --

　　 resources

　　 resource

　　 directory src/main/resources /directory

　　 includes

　　 include **/*.* /include

　　 /includes

　　 /resource

　　 /resources

　　注意：如果项目编译后 .xml/properties/yml 文件没有出现在 classes 目录下，则需要在 pom 中添加 resources 资源插件。

　　事务及mybatis自动代码生成器的使用

　　回顾 Spring 框架中的事务：

　　
管理事务的对象：事务管理器（接口，接口有很多的实现类）

　　例如：使用 Jdbc 或 mybatis 访问数据库，使用的事务管理器：DataSourceTransactionManager

　　
声明式事务：使用 xml 配置文件或者使用注解说明事务控制的内容

　　控制事务：隔离级别，传播行为，超时时间

　　
Spring 框架中的 @Transactional

　　Spring 支持 aspectj 框架的事务配置，可在 xml 配置文件中，声明事务控制的内容

　　
SpringBoot 中使用事务：上面的两种方式都可以。

　　使用步骤：（以下以注解方式演示事务的使用：）

　　
明确的在主启动类的上面，加入@EnableTransactionManager，启用事务管理器（可不用添加此注解）

　　
* @Transactional 表示方法有事务支持，抛出运行时异常，则进行回滚

　　 * 使用MySQL默认的传播行为、隔离级别、超时时间

　　@Transactional // 可通过属性配置传播行为、隔离级别、超时时间

　　@Override

　　public int addUser(User user) {

　　 System.out.println("业务方法addUser开始执行");

　　 int rows = userMapper.insert(user);

　　 System.out.println("业务方法addUser结束执行");

　　 // 模拟发生运行时异常

　　 // int num = 10 / 0;

　　 return rows;

　　SpringBoot 中通过注解使用事务，一句话说明：直接在需要开启事务的业务方法上添加 @Transactional 注解即可！

　　示例：（有mybatis自动代码生成器的使用示例，可自动生成 model 实体类， dao 接口以及 mapper 映射文件）

准备数据库表：

　　数据库名：springdb 表名：user

　　字段：id（int auto_increment）name（varchar）age（int）

　　
创建 SpringBoot 项目，添加 Spring Web、MyBatis、MySQL 依赖，整理项目目录和 pom 文件

　　
在 pom 的 plugins 标签下添加 mybatis 自动代码生成插件

 !--mybatis自动代码生成插件--

　　 plugin

　　 groupId org.mybatis.generator /groupId

　　 artifactId mybatis-generator-maven-plugin /artifactId

　　 version 1.3.6 /version

　　 configuration

　　 !--配置文件的位置：在项目的根目录下，和src平级--

　　 configurationFile GeneratorMapper.xml /configurationFile

　　 verbose true /verbose

　　 overwrite true /overwrite

　　 /configuration

　　 /plugin

　　
在 pom 的 build 标签下添加资源插件，处理资源文件，刷新 pom

 !-- 处理资源文件 --

　　 resources

　　 resource

　　 directory src/main/resources /directory

　　 includes

　　 include **/**.* /include

　　 /includes

　　 /resource

　　 /resources

　　
在项目根目录下创建 GeneratorMapper.xml文件，其与 src 平级；将下列内容拷贝到文件中；依照注释修改配置，修改完后，点开右侧 maven 快捷窗口，使用当前项目下 plugins 下 mybatis-genetate 下的 mybatis 自动代码生成插件进行生成。

 ?xml version="1.0" encoding="UTF-8"?

　　 !DOCTYPE generatorConfiguration

　　 PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"

　　 "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd"

　　 generatorConfiguration

　　 !-- 指定连接数据库的JDBC驱动包所在位置，指定到你本机的完整路径 --

　　 classPathEntry location="D:\Java\tools\mysql-connector-java-8.0.28.jar"/

　　 !-- 配置table表信息内容体，targetRuntime指定采用MyBatis3的版本 --

　　 context id="tables" targetRuntime="MyBatis3"

　　 !-- 抑制生成注释，由于生成的注释都是英文的，可以不让它生成 --

　　 commentGenerator

　　 property name="suppressAllComments" value="true" /

　　 /commentGenerator

　　 !-- 配置数据库连接信息 --

　　 jdbcConnection driver connectionURL="jdbc:mysql://localhost:3306/springdb?useUnicode=true amp;characterEncoding=UTF-8 amp;serverTimezone=GMT%2B8"

　　 userId="root"

　　 password="luis"

　　 !--MySQL 不支持 schema 或者 catalog 所以需要添加这个--

　　 !--设置原因参考：https://blog.csdn.net/qq_40233736/article/details/83314596--

　　 property name="nullCatalogMeansCurrent" value="true" /

　　 /jdbcConnection

　　 !-- 生成model类，targetPackage指定model类的包名， targetProject指定生成的model放在eclipse的哪个工程下面--

　　 javaModelGenerator targetPackage="com.luis.model"

　　 targetProject="D:\1a-Projects\springboot-projects\springboot-transactional\src\main\java"

　　 property name="enableSubPackages" value="false" /

　　 property name="trimStrings" value="false" /

　　 /javaModelGenerator

　　 !-- 生成MyBatis的Mapper.xml文件，targetPackage指定mapper.xml文件的包名， targetProject指定生成的mapper.xml放在eclipse的哪个工程下面 --

　　 sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources"

　　 property name="enableSubPackages" value="false" /

　　 /sqlMapGenerator

　　 !-- 生成MyBatis的Mapper接口类文件,targetPackage指定Mapper接口类的包。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读