A058_SpringBoot

XIAOMING820

已于 2023-07-20 16:44:38 修改

阅读量121

点赞数

分类专栏：文档文章标签： spring boot

于 2021-06-22 00:15:59 首次发布

本文链接：https://blog.csdn.net/ffhgjgj6576567/article/details/118096946

版权

文档专栏收录该内容

118 篇文章 6 订阅

订阅专栏

1.内容介绍

1. Spring Boot入门;（掌握）
2. Spring Boot简介;（了解）
3. Spring Boot web;（掌握）
4. Spring Boot 测试;（掌握）
5. Spring boot三层架构;（掌握）
7. Spring boot事务管理;（掌握）
8. Spring Boot ss-mybatis;（掌握）

2.Spring Boot简介

spring生态圈
在这里插入图片描述

2.1.什么是Spring Boot

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。 -使用springboot以后,搭建一个spring应用和开发变得很简单.
该框架使用了特定的方式(继承starter，约定优先于配置)来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。
Spring Boot并不是一个框架，从根本上将，它就是一些maven库的集合，maven或者gradle项目导入相应依赖即可使用Spring Boot，而且无需自行管理这些库的版本。
Springboot就是一些写好了maven的模块，我们在使用SPring就不需以传统的方式来用，只需要以maven导入对应的springboot模块，就能完成一大堆操作。简单的说，它使用maven的方式对Spring应用开发进行进一步封装和简化。

springboot是为 spring服务的，为简化Spring项目配置而生
它使用maven的方式对Spring应用开发进行进一步封装和简化
是用来简化spring应用搭建，开发，部署，监控的开发工具

2.2.为什么要使用Spring Boot；

Spring Boot是为简化Spring项目配置而生，使用它使得jar依赖管理以及应用编译和部署更为简单。Spring Boot提供自动化配置，使用Spring Boot，你只需编写必要的代码和配置必须的属性。
使用Spring Boot，只需20行左右的代码即可生成一个基本的Spring Web应用，并且内置了tomcat，构建的fat Jar包通过Java -jar就可以直接运行。 java -jar crm.jar
如上特性使得Spring Boot非常契合微服务的概念，可以结合Spring Boot与Spring Cloud和Docker技术来构建微服务并部署到云端：
一个可执行jar即为一个独立服务很容易加载到容器，每个服务可以在自己的容器（例如docker）中运行
通过一个脚本就可以实现配置与部署，很适合云端部署，并且自动扩展也更容易
简单而言，即Spring Boot使编码更简单，使配置更简单，使部署更简单，使监控更简单。！
Springboot就是为了简化spring应用搭建，开发，部署，监控的开发工具。

2.3.Spring Boot提供哪些功能

就是一些maven模块，我们需要知道有哪些模块，什么时候该导入什么模块。

2.3.1.无需手动管理依赖jar包的版本

Spring boot通过spring boot starter项目管理其提供的所有依赖的版本，当升级spring boot时，这些依赖的版本也会随之升级。个人无需指定版本号。
但是也可以自定义版本号覆盖springboot的默认值。每个版本的boot都有对应的base spring version，不建议明确地指定spring版本。
例如，使用maven时，只需简单的在pom中包含spring-boot-starter-web即引入了Spring MVC和Tomcat的依赖。
下面是Spring Boot在 org.springframework.boot 组下提供的一些Starters：
在这里插入图片描述
spring-boot-starter-web： web支持，其实就是springmvc简化使用。
Spring-boot-starter-jdbc： springboot对jdbc支持
Spring-boot-starter-data jpa： springboot对data jpa支持
Spring-boot-starter-mybatis： springboot对mybatis支持
Spring-boot-starter-test： springboot对test支持
Spring-boot-starter-redis
Spring-boot-starter-es
Spring-boot-starter-sorl

总之springboot就是简化spring应用开发，对web，service，dao层都支持。

ssj

3.Spring boot入门

3.1.环境要求

开发环境JDK 1.8
项目管理工具（ Maven ）
开发工具(Eclipse/idea)

3.2.入门

3.2.1.创建Maven项目

略过

3.2.2.导入Spring Boot依赖

<!-- 
spring boot 父节点依赖,引入这个之后相关的引入就不需要添加version配置，spring boot会自动选择最合适的版本进行添加。
 -->
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.0.5.RELEASE</version>
</parent>

添加spring-boot-starter-web依赖

<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
</dependency>

3.2.3.编码测试

新建一个Controller类
在这里插入图片描述
新建启动类(App – Main方法)

测试代码
运行:App
浏览器：http://localhost:8080/hello

步骤总结:

创建maven项目
springboot_parent
springboot_01_hello
springboot_02_web
新建启动类完成启动 @SpringBootApplication SpringApplication.run

@SpringBootApplication//标识该应用为springboot的应用
public class HelloApplication {
    public static void main(String[] args) {
        //启动springboot应用
        SpringApplication.run(HelloApplication.class);
    }
}

写controller,启动后完成测试

@Controller
@RequestMapping("/hello")
public class HelloController {
    @RequestMapping("/hi1")
    @ResponseBody //直接作为字符串返回而不是页面地址
    public String sayHello(String name){
        return name +" say hello";
    }
}

3.3.springboot运行方式

3.3.1.在ide中直接通过main函数启动

开发时候

3.3.2.插件运行

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

子项目Pom.xml中贴上插件依赖，install，视图-工具窗口-Maven， spring-boot:run

3.3.3.打包运行

项目上线 java -jar xxx.jar 只依赖jdk
打包:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

cmd
mvn clean package spring-boot:repackage

运行:
java -jar xxx.jar
Maven-Package，从target目录下进入生成jar包的文件夹， cmd java -jar xxx.jar

3.3.4.热部署

即使修改了输出内容也要重启APP，非常麻烦！可以使用spring-boot-devtools来实现热部署！

介绍
spring-boot-devtools 是一个为开发者服务的一个模块，其中最重要的功能就是自动应用代码更改到最新的App上面去。原理是在发现代码有更改之后，重新启动应用，但是速度比手动停止后再启动还要更快，更快指的不是节省出来的手工操作的时间。其深层原理是使用了两个ClassLoader，一个Classloader加载那些不会改变的类（第三方Jar包），另一个ClassLoader加载会更改的类（自己写的），称为 restart ClassLoader，这样在有代码更改的时候，原来的restart ClassLoader 被丢弃，重新创建一个restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间（5秒以内）
使用
添加依赖包：

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <optional>true</optional>
      <scope>true</scope>
</dependency>

添加spring-boot-maven-plugin：

<build>
		<plugins>
		    <plugin>
	            <groupId>org.springframework.boot</groupId>
	            <artifactId>spring-boot-maven-plugin</artifactId>
	            <configuration>
	          		<!--fork :  如果没有该项配置，可能devtools不会起作用，即应用不会restart -->
	                <fork>true</fork>
	            </configuration>
	        </plugin>
		</plugins>
   </build>

在idea中需要手动编译一下,ctrl+F9
热部署
1.添加依赖、 2.启动项目、 3.改代码、
4.重新编译（关键）（编译:改动哪个类只加载哪个类，不会加载配置文件等）

3.4.小结

本节主要是SpringBoot的基本引入及热部署的集成

4.Spring boot配置

4.1.引入

前面我们看到访问的端口是8080，我们想把他改为9090,可以不，当然可以。在修改之前先学习一下关于配置文件的知识

4.2.配置文件

SpringBoot使用一个全局的配置文件，配置文件名是固定的；
•application.properties - 传统方式，不太优美
•application.yml - 推荐使用
配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好；

YAML做配置一门语言：
以前的配置文件；大多都使用的是 xxxx.xml文件还有properties；
YAML：以数据为中心，比json、xml等更适合做配置文件；
YAML：配置例子

    server:
      port: 8081

XML：

    <server>
    	<port>8081</port>
    </server>

properties:

 server.port =8081

SpringBoot的配置文件
application.yml
application.properties (首选)
1.有了properties 可以存在yml吗？可以存在
2.如果同时存在，我该用谁？优先用properties，但是可以同时使用不一样的配置

4.3.YML语法

4.3.1.基本语法

k:(空格)v：表示一对键值对（空格必须有）；

以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的

    server:
        port: 8081
        path: /hello

属性和值也是大小写敏感；

4.3.2.值得写法

1）字面量：普通的值（数字，字符串，布尔）

	k: v：字面直接来写；

		字符串默认不用加上单引号或者双引号；

		""：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思

				name:   "zhangsan \n lisi"：输出；zhangsan 换行  lisi

		''：单引号；会转义特殊字符，特殊字符最终只是一个普通的字符串数据

				name:   ‘zhangsan \n lisi’：输出；zhangsan \n  lisi

2）k: v：在下一行来写对象的属性和值的关系；注意缩进

		对象还是k: v的方式

    friends:
    		lastName: zhangsan
    		age: 20

行内写法：

    friends: {lastName: zhangsan,age: 18}


3）数组（List、Set）：

用- 值表示数组中的一个元素

    pets:
     - cat
     - dog
     - pig

行内写法

    pets: [cat,dog,pig]

4.4.Profile多环境支持

4.4.1.为什么要做多环境配置

一套代码要在多种环境运行(开发,测试,上线),所以我们的配置文件要支持多种环境

4.4.2.多文件模式

我们在主配置文件编写的时候，文件名可以是 application-{profile}.properties/yml

application-dev.yml

application-test.yml

默认使用application.properties的配置；
在这里插入图片描述

4.4.3.多文档块模式(不推荐)

Application.yml

server:
  port: 8081		#active未指定时的默认配置
spring:
  profiles:
    active: prod
---
server:
  port: 8083
spring:
  profiles: dev
---
server:
  port: 8084
spring:
  profiles: prod  	#指定属于哪个环境

在这里插入图片描述

4.4.4.激活特定环境

1、在配置文件中指定  spring.profiles.active=dev

2、命令行： 部署环境

	java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod；

	可以直接在测试的时候，配置传入命令行参数

3、虚拟机参数； 开发环境

	-Dspring.profiles.active=dev

5.整合测试-springboot-test

5.1.引入

后续的学习过程中，每次都要写controller来访问测试比较麻烦，其他我们可以通过springboot的测试直接测试。就和原来不用启动tomcat一样测试

5.2.导入spring-boot-starter-test

在原有基础上面导入spring-boot-starter-test

     <dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
		</dependency>

5.3.创建一个SpringBoot应用，并在下面创建一个Bean

 @SpringBootApplication
public class App {

	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}
}

@Component
@Data
public class MyBean {

    private String name;
    private Integer age;
}

5.4.写SpringBoot测试从Springboot中获取bean就ok

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class) //这是一个Spring测试，要告诉它在哪儿加载Spring配置文件，其实告诉它应用类型就ok
public class SpringbootTest {
	//	@Autowired
	//	private TestService testService;
    @Autowired
	MyBean myBean;
	@Test
	public void test() throws Exception {
	//	System.out.println(testService);
	//	testService.test();
	System.out.println(myBean);
	}
}

6.Springboot-web

6.1.获取Json数据

package cn.itsource.springboot.controller;
import cn.itsource.springboot.domain.Person;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

@Controller
@RequestMapping("/json1")
public class JsonController {

    //字符串
    @RequestMapping("/str")
    @ResponseBody
    public String json1(){
        return "yhptest";
    }
    //对象-日期

    @RequestMapping("/obj")
    @ResponseBody
    public Person json2(){
        return new Person(1L,"yhptest",new Date());
    }

    //数组
    @RequestMapping("/array")
    @ResponseBody
    public List<Person> json3(){
        return Arrays.asList(new Person(1L,"yhptest",new Date())
                ,new Person(2L,"yaohuaipeng",new Date()));
    }
}

package cn.itsource.springboot.controller;
import cn.itsource.springboot.domain.Person;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

@RestController //@RestController=@Controller+@ResponseBody 官方推荐就使用
@RequestMapping("/json2")
public class JsonController2 {

    //字符串
    @RequestMapping("/str")
    public String json1(){
        return "yhptest";
    }
    //对象-日期

    @RequestMapping("/obj")
    public Person json2(){
        return new Person(1L,"yhptest",new Date());
    }

    //数组
    @RequestMapping("/array")
    public List<Person> json3(){
        return Arrays.asList(new Person(1L,"yhptest",new Date())
                ,new Person(2L,"yaohuaipeng",new Date()));
    }
}

6.2.入门-返回页面

6.2.1.模板引擎分析

3.3.1.1 常见的模板引擎

JSP、Velocity、Freemarker、Thymeleaf
在这里插入图片描述
SpringBoot推荐的Thymeleaf；

语法更简单，功能更强大；

3.3.1.2 Thymeleaf入门

1）引入

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
		
	<properties>
		<!--切换thymeleaf版本-->
		<thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
		<!-- 布局功能的支持程序  thymeleaf3主程序  layout2以上版本 -->
		<!-- thymeleaf2   layout1-->
		<thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
    </properties>

2）使用
模板存放位置
在这里插入图片描述

只要我们把HTML页面放在classpath:/templates/，thymeleaf就能自动渲染；

package cn.itsource.springboot.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @author yaohuaipeng
 * @date 2019/8/21-22:41
 */
@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model model){
        model.addAttribute("hello","yhptest");
        return "hello";
    }
}

<!DOCTYPE html>
<!--导入命名空间 -->
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>成功！</h1>
    <!--使用语法th:text 将div里面的文本内容设置为 -->
    <div th:text="${hello}">这是显示欢迎信息</div>
</body>
</html>

3）细节
①th:text；改变当前元素里面的文本内容；
th：任意html属性；来替换原生属性的值
在这里插入图片描述

②表达式？

Simple expressions:（表达式语法）
Variable Expressions: ${...}：获取变量值；OGNL；
1）、获取对象的属性、调用方法
2）、使用内置的基本对象：
#ctx : the context object.
#vars: the context variables.
#locale : the context locale.
#request : (only in Web Contexts) the HttpServletRequest object.
#response : (only in Web Contexts) the HttpServletResponse object.
#session : (only in Web Contexts) the HttpSession object.
#servletContext : (only in Web Contexts) the ServletContext object.
${session.foo}
3）、内置的一些工具对象：
#execInfo : information about the template being processed.
#messages : methods for obtaining externalized messages inside variables
expressions, in the same way as they would be obtained using #{…} syntax.
#uris : methods for escaping parts of URLs/URIs
#conversions : methods for executing the configured conversion service (if any).
#dates : methods for java.util.Date objects: formatting, component extraction, etc.
#calendars : analogous to #dates , but for java.util.Calendar objects.
#numbers : methods for formatting numeric objects.
#strings : methods for String objects: contains, startsWith, prepending/appending,
etc.
#objects : methods for objects in general.
#bools : methods for boolean evaluation.
#arrays : methods for arrays.
#lists : methods for lists.
#sets : methods for sets.
#maps : methods for maps.
#aggregates : methods for creating aggregates on arrays or collections.
#ids : methods for dealing with id attributes that might be repeated (for example,
as a result of an iteration).
Selection Variable Expressions: *{...}：选择表达式：和${}在功能上是一样；
补充：配合 th:object="${session.user}：
<div th:object="${session.user}">
<p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
<p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
<p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>
</div>
Message Expressions: #{...}：获取国际化内容
Link URL Expressions: @{...}：定义URL；
@{/order/process(execId=${execId},execType='FAST')}
Fragment Expressions: ~{...}：片段引用表达式
<div th:insert="~{commons :: main}">...</div>
Literals（字面量）
Text literals: 'one text' , 'Another one!' ,…
Number literals: 0 , 34 , 3.0 , 12.3 ,…
Boolean literals: true , false
Null literal: null
Literal tokens: one , sometext , main ,…
Text operations:（文本操作）
String concatenation: +
Literal substitutions: |The name is ${name}|
Arithmetic operations:（数学运算）
Binary operators: + , - , * , / , %
Minus sign (unary operator): -
Boolean operations:（布尔运算）
Binary operators: and , or
Boolean negation (unary operator): ! , not
Comparisons and equality:（比较运算）
Comparators: > , < , >= , <= ( gt , lt , ge , le )
Equality operators: == , != ( eq , ne )
Conditional operators:条件运算（三元运算符）
If-then: (if) ? (then)
If-then-else: (if) ? (then) : (else)
Default: (value) ?: (defaultvalue)
Special tokens:
No-Operation: _

7.Spring boot持久化支持

7.1.引入

前面我们已经对springboot进行了入门，并且讲了它的配置，并且日志支持也做了说明。而且我们还说明springboot是spring应用的一站式解决方案，接下来我们就对我们三层结构中各个角色进行学习。
我们依次学习web(SpringMVC) 持久化(jdbc,mybatis,data jpa) 业务层事务测试

7.2.整合Mybatis

7.2.1.Xml及注解版本实现

（1）新建maven project;
新建一个maven project,取名为：spring-boot-mybatis
（2）在pom.xml文件中引入相关依赖；
（1）基本依赖，jdk版本号；
（2）mysql驱动，mybatis依赖包，mysql分页PageHelper:

<!-- mysql 数据库驱动. -->
    <dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
	</dependency>	

	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-jdbc</artifactId>
	</dependency>


<!-- 	
			spring-boot mybatis依赖：
			
			请不要使用1.0.0版本，因为还不支持拦截器插件，
	    	1.1.1 是博主写帖子时候的版本，大家使用最新版本即可
	     -->
	<dependency>
	    <groupId>org.mybatis.spring.boot</groupId>
	    <artifactId>mybatis-spring-boot-starter</artifactId>
	    <version>1.1.1</version>
	</dependency>
<!-- 
    	MyBatis提供了拦截器接口，我们可以实现自己的拦截器，
    	将其作为一个plugin装入到SqlSessionFactory中。 
		Github上有位开发者写了一个分页插件，我觉得使用起来还可以，挺方便的。 
		Github项目地址： https://github.com/pagehelper/Mybatis-PageHelper
     -->	
    <dependency>
	    <groupId>com.github.pagehelper</groupId>
	    <artifactId>pagehelper</artifactId>
	    <version>4.1.0</version>
	</dependency>

（3）创建启动类App.java

@SpringBootApplication
@MapperScan("cn.itsource.springboot.mybatis.mapper")
public class App {
	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}
}

//这里和以往不一样的地方就是MapperScan的注解，这个是会扫描该包下的接口

（4）在application.properties添加配置文件；

########################################################
###datasource
########################################################
spring.datasource.url = jdbc:mysql://localhost:3306/test
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10

（5）编写Demo测试类;

public class Demo {
	private long id;
	private String name;
      //省略getter and setter….
}

（6）编写DemoMapper；
注解：

public interface DemoMappper {
	
	@Select("select *from Demo where name = #{name}")
	public List<Demo> likeName(String name);
	
	@Select("select *from Demo where id = #{id}")
	public Demo getById(long id);
	
	@Select("select name from Demo where id = #{id}")
	public String getNameById(long id);
}

（7）编写DemoService

@Service
public class DemoService {
	@Autowired
	private DemoMappper demoMappper;
	
    public List<Demo> likeName(String name){
        return demoMappper.likeName(name);
    }
}

（8）编写DemoController;

@RestController
public class DemoController {
	@Autowired
	private DemoService demoService;
	
	@RequestMapping("/likeName")
	public List<Demo> likeName(String name){
		return demoService.likeName(name);
	}
}

//运行访问：http://127.0.0.1:8080/likeName?name=张三  就可以看到返回的数据了
一:加上Mapper扫描路径
@MapperScan("cn.itsource.springboot.mapper")
二 映射
	注解版本:
		打注解 
	xml版本
		1) 配置Mapper的xml文件
	    2) 配置别名
		别名:mybatis.type-aliases-package=

7.2.2.配置事务

声明式: 配置事务管理器配置通知配置切面（切入后要应用通知）

<!-- 配置事物管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	  <property name="dataSource" ref="dataSource" />
	</bean>
	<!-- aop应用事务管理 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="get*" read-only="true"/>
			<tx:method name="select*" read-only="true"/>
			<tx:method name="search*" read-only="true"/>
			<tx:method name="query*" read-only="true"/>
			<tx:method name="*" propagation="REQUIRED" read-only="true"/>
		</tx:attributes>
	</tx:advice>
	<aop:config>
		<aop:pointcut expression="execution(* cn.itsource.eloan.core.service..*.*(..))" id="coreServicePointcut"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="coreServicePointcut"/>
	</aop:config>

原来实现：
	1）事务管理器
	2）开启注解，就是能够识别@Transactional
	3）在要控制事务的Service的或方法上面加上@Transactional
	     建议：类级别为只读事务，需要写事务的方法上面加写事务 
SpringBoot：注解式事务
    所有配置springboot都已经实现了，只需打注解即可。

7.2.3.使用PageHelper分页

    PageHelper是mybatis一个插件,可以用它完成分页
    导入jar
   配置

@Configuration
public class MyBatisConfiguration {
	
	@Bean
    public PageHelper pageHelper() {
		System.out.println("MyBatisConfiguration.pageHelper()");
        PageHelper pageHelper = new PageHelper();
        Properties p = new Properties();
        p.setProperty("offsetAsPageNum", "true");
        p.setProperty("rowBoundsWithCount", "true");
        p.setProperty("reasonable", "true");
        pageHelper.setProperties(p);
        return pageHelper;
    }
}

测试

@RequestMapping("/likeName")
public List<Demo> likeName(String name){
		 PageHelper.startPage(1,1);
	     return demoService.likeName(name);
}

7.2.4.获取自增Id

@Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "id") 
@Insert("insert into Demo(name,password) values(#{name},#{password})") 
public long save(Demo name);//对象上面也有