2、SpringBoot创建web项目并操作数据库实例 - Go语言中文社区

2、SpringBoot创建web项目并操作数据库实例

  1. 课程介绍

  • 1. Spring Boot入门;（了解）

  • 2. Spring Boot简介;（了解）

  • 3. Spring Boot简介web;（掌握）

  • 4. Spring Boot测试;（掌握）

  • 5. Spring Boot三层架构;（掌握）

  • 6. Spring Boot 持久化;（掌握）

  • 7. Spring boot模块化开发;（掌握）

2、Spring Boot简介 

2.1、什么是Spring Boot

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。

该框架使用了特定的方式(继承starter，约定优先于配置)来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。

Spring Boot并不是一个框架，从根本上将，它就是一些maven库的集合，maven或者gradle项目导入相应依赖即可使用Spring Boot，而且无需自行管理这些库的版本。。

Spring Boot就是一些开发好了maven模块,只需导入对应模块就能做对应事情.只需要springboot提供了哪些模块,每个模块是干嘛的.最终使用时判断要做那个功能,选择对应模块就ok. 该做什么事情了，需要导入哪个模块。

2.2、 为什么要使用Spring Boot

Spring Boot是为简化Spring项目配置而生，使用它使得jar依赖管理以及应用编译和部署更为简单。Spring Boot提供自动化配置，使用Spring Boot，你只需编写必要的代码和配置必须的属性。

使用Spring Boot，只需20行左右的代码即可生成一个基本的Spring Web应用，并且内置了tomcat，构建的fat Jar包通过Java -jar就可以直接运行。

如下特性使得Spring Boot非常契合微服务的概念，可以结合Spring Boot与Spring Cloud(dubbo)和Docker技术来构建微服务并部署到云端：

  • 一个可执行jar即为一个独立服务很容易加载到容器，每个服务可以在自己的容器（例如docker）中运行
  • 通过一个脚本就可以实现配置与部署，很适合云端部署，并且自动扩展也更容易

Springboot是为了简化Spring向的开发. 简单而言，即Spring Boot使编码更简单，使配置更简单，使部署更简单，使监控更简单,使生活变得更美好。！

2.3、Spring Boot提供哪些功能

  • 无需手动管理依赖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就是一些开发好了maven模块,只需导入对应模块就能做对应事情.

springmvc

spring jdbc

data jpa

spring-boot-start-mybatis mybatis  mybatis

spring-security

事务管理   service

spring-boot-start-test 测试

等等

Springboot没有引入新技术，就是把原来spring相关技术，进行maven模块封装，让我们使用起来更加简单。

 

3、Spring boot入门

3.1、环境要求

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

3.2、创建Maven项目

  • 创建项目，选择简单maven项目即可。
  • 导入Spring Boot依赖
<!--
spring boot 父节点依赖,引入这个之后相关的引入就不需要添加version配置，spring boot会自动选择最合适的版本进行添加。
-->

<parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>1.4.1.RELEASE</version>
</parent>

添加spring-boot-starter-web依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
  • 编码测试

（1）新建一个Controller类

（2）新建启动类(App – Main方法)

 

  • 测试代码

运行:App

            浏览器：http://localhost:8080/hello

  • 热部署

 即使修改了输出内容也要重启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>

 

4、Spring boot web

4.1 引入

前面我们使用Spring Boot能往浏览器中输出一个字符串！实际上我们需要的是跳转到一个页面或者获取一个Json数据。那怎么实现呢？

  • 跳转Jsp

步骤：

  •    创建Maven web project
  •    引入依赖
  •    配置application.properties对jsp支持
  •    编写并启springboot应用
  •    编写APP
  •    编写测试Controller
  •    返回页面JSP
  •    返回json

（1）创建Maven Web Project

使用Eclipse新建一个Maven Web Project ，项目取名为：spring-boot-jsp

（2）导入Maven依赖

<!-- spring boot parent节点，引入这个之后，在下面和spring boot相关的就不需要引入版本了; -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.1.RELEASE</version>
</parent>

<!-- 指定一下jdk的版本 ，这里我们使用jdk 1.8 ,默认是1.6 -->
<java.version>1.8</java.version>

<!-- 依赖配置-->
<!-- web支持: 1、web mvc; 2、restful; 3、jackjson支持; 4、aop ........ -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- servlet 依赖. -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <scope>provided</scope>
</dependency>

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>jstl</artifactId>
</dependency>

<!-- tomcat 的支持. -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-tomcat</artifactId>
   <scope>provided</scope>
</dependency>

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <scope>provided</scope>
</dependency>

 

（3）搭建一个springboot应用

app main

（4）跳转页面

配置application.properties对jsp支持，添加src/main/resources/application.properties：

# 页面默认前缀目录
spring.mvc.view.prefix=/WEB-INF/jsp/
# 响应页面默认后缀
spring.mvc.view.suffix=.jsp
# 自定义属性，可以在Controller中读取
application.hello=Hello Angel From application

编写测试Controller

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {

     @RequestMapping("/hello")
     public String helloJsp(Model model){
         System.out.println("HelloController.helloJsp().hello=hello");
         model.addAttribute("hello", "你好");
         return "hello";
     }
}

 

在 src/main 下面创建 webapp/WEB-INF/jsp 目录用来存放我们的jsp页面：helloJsp.jsp:

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

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Insert title here</title>
    </head>

    <body>
        helloJsp<hr>
        ${hello}
    </body>
</html>

 

（5）返回Json

要把Java对象转换为Json框架，使用的是JackSon，maven依赖的jar也有

   @RequestMapping("/json")
   @ResponseBody
   public Person json(){
      return new Person(1L,"倪先华");
   }

 

（5）启动App并测试

 

5、三层架构

  • Service :Spring来做事务管理
  • Web:Spring MVC
  • DAO:各种持久化技术-jdbc,mybatis.spring data jpa

Spring集中管理

  • 搭建三层结构-不要考虑持久化层，打印即可,无法测试事务

  • 模拟实现:dao+service+junit+controller

  • 真实实现:持久化实现

  • 每个框架 jdbc mybatis data jpa
  • 事务

5.1 导入spring-boot-starter-test

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

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

     <!-- web支持: 1、web mvc; 2、restful; 3、jackjson支持; 4、aop ........ -->
     <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
     </dependency>

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

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

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

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class) //这事一个Spring测试，要告诉它在哪儿加载Spring配置文件，其实告诉它应用类型就ok

public class SpringbootTest {
   @Autowired
   private TestService testService;

   @Test
   public void test() throws Exception {
     System.out.println(testService);
     testService.test();
   }
}

 

5.4、Spring boot 持久化

Spring Boot就数据库持久化支持，支持原生Jdbc，也支持Mybatis和data JPA。Spring boot JdbcTemplate，引入spring-boot-starter-jdbc，那么只需要在需要使用的类中加入：

@Resource
private JdbcTemplate jdbcTemplate;

前台：表

 

引入Maven依赖-mysql，jdbc

<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
</dependency>

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

 

数据库信息配置，在application.properties文件中配置mysql连接配置文件

########################################################
###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

编写代码测试

 

domain/表-导入jar-数据库配置-写dao（JdbcTemplate）-junit测试

 

事务支持

1）声明式（xml）

<!-- 配置自动扫描mybatis映射器，自动创建映射器对象 -->

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

        <!-- 会根据cn.itsource.eloan.core.mapper包中定义的接口，自动创建Mapper对象；bean的名为接口的名字（首字母小写） -->

        <property name="basePackage" value="cn.itsource.eloan.core.mapper" />

    </bean>

    

    <!-- 配置事物管理器 -->

    <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*" 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"/>

        </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>

2）注解式

  ①配置事务管理器

  ②开发注解式事务支持-能够识别并处理我们打注解

  ③在Service上面加@Transactional

springboot采用的是注解式，并且①和②已经默认配置，我们只需在对应的类上面打注解即可。

 

Spring boot-spring data Jpa

Spring Data是一个用于简化数据库访问，并支持云服务的开源框架。其主要目标是使得数据库的访问变得方便快捷，并支持map-reduce框架和云计算数据服务。此外，它还支持基于关系型数据库的数据服务，如Oracle RAC等。对于拥有海量数据的项目，可以用Spring Data来简化项目的开发，就如Spring Framework对JDBC、ORM的支持一样，Spring Data会让数据的访问变得更加方便。

  1. Jpa

“规范”： 所谓的规范意指明文规定或约定俗成的标准。如：道德规范、技术规范，公司管理规范。那么“持久化规范”就是Sun针对持久化这一层操作指定的规范，如果没有指定JPA规范，那么新起的框架就随意按照自己的标准来了，那我们开发人员就没法把我们的经历全部集中在我们的业务层上，而是在想如何进行兼容，这种情况有点像Android开发，Android本身有官方的SDK,但是由于SDK过于开源了，结果导致很多厂商基于SDK二次开发，但是兼容性就不是很好，最好的例子就是Android的头像上传，就是一件很烦人的事情。好了，JPA就介绍到这里。

  1. Hibernate

             JPA是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的      toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。

  1. Spring data Jpa

Spring Data JPA能干什么

可以极大的简化JPA的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD外，还包括如分页、排序等一些常用的功能。

    首先我们需要清楚的是Spring Data是一个开源框架，在这个框架中Spring Data JPA只是这个框架中的一个模块，所以名称才叫Spring Data JPA。如果单独使用JPA开发，你会发现这个代码量和使用JDBC开发一样有点烦人，所以Spring Data JPA的出现就是为了简化JPA的写法，让你只需要编写一个接口继承一个类就能实现CRUD操作了

 

5)Spirng data jpa常用接口或类

Spring Data 的一个核心接口为我们提供了常用的接口

Repository 接口是 Spring Data 的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法 ：

 public interface Repository<T, ID extends Serializable> { }

1. Repository是一个空接口，即是一个标记接口；

2. 若我们定义的接口继承了Repository，则该接口会被IOC容器识别为一个Repository Bean纳入到IOC容器中，进而可以在该接口中定义满足一定规范的方法。

3. 实际上也可以通过@RepositoryDefinition,注解来替代继承Repository接口。

4. 查询方法以find | read | get开头；

5. 涉及查询条件时，条件的属性用条件关键字连接，要注意的是条件属性以首字母大写。

6.使用@Query注解可以自定义JPQL语句实现更灵活的查询。

CrudRepository 接口提供了最基本的对实体类的添删改查操作

 --T save(T entity);//保存单个实体   

  --Iterable<T> save(Iterable<? extends T> entities);//保存集合         

  --T findOne(ID id);//根据id查找实体          

  --boolean exists(ID id);//根据id判断实体是否存在          

  --Iterable<T> findAll();//查询所有实体,不用或慎用!          

  --long count();//查询实体数量          

  --void delete(ID id);//根据Id删除实体          

  --void delete(T entity);//删除一个实体   

  --void delete(Iterable<? extends T> entities);//删除一个实体的集合          

  --void deleteAll();//删除所有实体,不用或慎用!   

PagingAndSortingRepository接口

该接口提供了分页与排序功能  

 --Iterable<T> findAll(Sort sort); //排序   

--Page<T> findAll(Pageable pageable); //分页查询（含排序功能）

JpaRepository：查找所有实体，排序、查找所有实体，执行缓存与数据库同步

JpaSpecificationExecutor：不属于Repository体系，实现一组 JPA Criteria 查询相关的方法，封装  JPA Criteria 查询条件。通常使用匿名内部类的方式来创建该接口的对象。

自定义 Repository：可以自己定义一个MyRepository接口。

 ==============================

jpa：Java Persistence API java数据库持久化规范。仅仅是规范，没有实现。

hibernate：jpa一种实现（注解版），当然它不仅实现了jpa，还有自己xml实现。

    传统经典架构：ssh-struts2+spring+hibernate(xml版)

    现在流行两种结构：

      ssj-springmvc + spring + jpa(hibernate注解版)

      ssm-springmvc + spring +mybatis(ibatis)

spirng data:spring提供对数据访问，对于不同数据存储方式有可以分为以下组成：

   spring data jpa：对数据库访问

   spring data redis:对redis的访问

   spring data mogodb：对mogodb的访问

  ....

spring data jpa:spring data对数据库持久化的支持。

    简化了Jpa生操作，crud都已经封装好了。

springboot spring data jpa

   再次对spring data jpa进行配置简化

https://www.ibm.com/developerworks/cn/opensource/os-cn-spring-jpa/index.html、

  1. 引入Maven依赖-mysql,springdatajpa

<dependency>

        <groupId>mysql</groupId>

        <artifactId>mysql-connector-java</artifactId>

</dependency>

<dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

  1. 配置jdbc spring data jpa

在application.properties文件中配置mysql连接配置文件

########################################################

###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

########################################################

### Java Persistence Api

########################################################

# Specify the DBMS

spring.jpa.database = MYSQL

# Show or not log for each sql query

spring.jpa.show-sql = true

# Hibernate ddl auto (create, create-drop, update)

spring.jpa.hibernate.ddl-auto = update

# Naming strategy

#[org.hibernate.cfg.ImprovedNamingStrategy  #org.hibernate.cfg.DefaultNamingStrategy]

spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy

# stripped before adding them to the entity manager)

spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

 

编写代码测试

(1) 创建实体类并完成关系映射。

(2) 创建继承与JpaRepository的接口

(3) 创建service类。

    使用Repository的接口注入本地代理对象

  1. 测试;

  1. 扩展jpa Repository

        

     

Spring boot-mybtis

  1. 集成Mybatis

  1. 新建maven project;

新建一个maven project,取名为：spring-boot-mybatis

  1. 在pom.xml文件中引入相关依赖；

（1）基本依赖，jdk版本号；

（2）mysql驱动，mybatis依赖包，mysql分页PageHelper:

<!-- mysql 数据库驱动. -->
<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</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>

在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

########################################################
### Java Persistence Api
########################################################
# Specify the DBMS
spring.jpa.database = MYSQL
# Show or not log for each sql query
spring.jpa.show-sql = true
# Hibernate ddl auto (create, create-drop, update)
spring.jpa.hibernate.ddl-auto = update
# Naming strategy
#[org.hibernate.cfg.ImprovedNamingStrategy  #org.hibernate.cfg.DefaultNamingStrategy]
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy
# stripped before adding them to the entity manager)
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

 

创建启动类App.java

@SpringBootApplication
@MapperScan("cn.itsource.springboot.mybatis.mapper")//别名:mybatis.type-aliases-package=cn.itsource.springboot.ssm.domain

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

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

注解版

编写Demo测试类;

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

}

 

编写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);
}

XML

编写DemoService

@Service
public class DemoService {
    @Autowired
    private DemoMappper demoMappper;

    public List<Demo> likeName(String name){
        return demoMappper.likeName(name);
    }
}

编写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=

cn.itsource.springboot.ssm.domain

映射文件路径:

    ① 默认在接口同包同名映射配置文件

  1. 使用PageHelper分页

<!--

        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>   

@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);

}

  1. 获取自增Id

xml:

<!-- void save(User user);

       useGeneratedKeys="true" 返回自增id

         keyProperty="id" 对象的属性名

      keyColumn="id" 表的字段名

    -->

    <insert id="save" parameterType="User"

      useGeneratedKeys="true"

      keyProperty="id"

      keyColumn="id"

    >

        insert into t_user(name) values(#{name})

    </insert>

注解:

@Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "id")

@Insert("insert into Demo(name,password) values(#{name},#{password})")

public long save(Demo name);//对象上面也有

  1. 模块化开发

  1. 总结

  2. 课程总结

    1. 重点

      1. Spring Boot入门

      2. Spring Boot Web

      3. Spring Boot 持久化

      4. Spring Boot SSM

  3. 难点

    1. Spring Boot Web

    2. Spring Boot 持久化

    3. Spring Boot SSM

  1. 如何掌握？

    1. 勤加练习...

    2. 学会看说明手册

  1. 排错技巧（技巧）

    1. ...

    2. ...

  2. 课后练习

    1. 今天代码

  3. 面试题

    1. 为什么使用Spring Boot

  4. 扩展知识或课外阅读推荐（可选）

    1. 扩展知识

    2. 课外阅读

    Spring Boot集成Jedis,定时任务

版权声明：本文来源CSDN，感谢博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/lixiang987654321/article/details/81365996
站方申明：本站部分内容来自社区用户分享，若涉及侵权，请联系站方删除。
  • 发表于 2020-03-01 22:50:20
  • 阅读 ( 1452 )
  • 分类：数据库

你可能感兴趣的文章

精选的优质文章

0 条评论

请先 登录 后评论

官方社群

GO教程

推荐文章

猜你喜欢

随便看看

来源51CTO

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！