最近有些时间想到了整合通用mapper，浪费了好些力气！ （本人是一个菜鸟，把它整理起来以供参考，如果有什么问题请留言，共同进步）
搭建环境：
- 编译器：eclipse
- Maven : maven3.0
- JDK: java8
- 系统: win7
- 数据库: mysql5.6
先将我的项目结构展示一下：
首先利用工具生成springboot项目
生成项目的pom.xml文档如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- Spring boot 父引用-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.21.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.zhanghui</groupId>
<artifactId>test-root</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>SpringbootDemoTest</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- Spring boot 核心web-->
<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>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
以上为自动生成 如果您生成的pom文件没有web依赖请自行添加 因为没有这个依赖项目启动不了
新建一个controller：
package com.zhanghui.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class TestController {
@RequestMapping("/")
@ResponseBody
String home(){
return "hello world!";
}
}
目录结构参考最开始的那张图！然后启动项目 并访问 http://localhost:8080/ 出现下图表示成功！（项目默认端口8080，也可以自己进行配置 在properties文件中）
备注 ：需要将启动类放在其他类的包的外面 不然启动时启动类扫描不到其他类会报错
继续添加实体类:
package com.zhanghui.entity;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
public class user {
private Integer id;
private String userName = "张三";
private String passWord = "123456";
@JsonFormat
private Date createTime;
private String mark;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public String getMark() {
return mark;
}
public void setMark(String mark) {
this.mark = mark;
}
}
再添加service业务类：
package com.zhanghui.service;
import org.springframework.stereotype.Service;
import com.zhanghui.entity.user;
@Service
public class TestService {
public user getUser(){
return new user();
}
}
然后使用@autowired将service注入到controller中，controller类新加方法如下
package com.zhanghui.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.zhanghui.entity.user;
import com.zhanghui.service.TestService;
@Controller
public class TestController {
@RequestMapping("/")
@ResponseBody
String home(){
return "hello world!";
}
//注入service类
@Autowired
private TestService testService;
//新加方法
@RequestMapping("/get")
@ResponseBody
public user getUser(){
return testService.getUser();
}
}
注意：不要忘记添加@service注解 不然向service注入时会报错
启动服务，访问http://localhost:8080/get出现下图表示成功！
到此，符合处理http/json 的web框架已经搭建好了
》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
接下来添加日志
–Springboot自带日志，首先直接在SpringBoot中添加日志
改变controller类：
package com.zhanghui.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.zhanghui.entity.user;
import com.zhanghui.service.TestService;
@Controller
public class TestController {
//增加日志
private static final Logger LOGGER = LoggerFactory.getLogger(TestController.class);
@RequestMapping("/")
@ResponseBody
String home(){
return "hello world!";
}
//注入service类
@Autowired
private TestService testService;
//新加方法
@RequestMapping("/get")
@ResponseBody
public user getUser(){
//打印日志
LOGGER.info("此处添加日志！！");
return testService.getUser();
}
}
启动服务，访问http://localhost:8080/get当控制台显示如下图表示成功：
接下来要将日志生成文件保存到我们制定的文件夹中
–日志按天记录，自动生成当天的记录文件
先在pom中添加依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</dependency>
接着在resource下添加logback配置文件logback.xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
<property name="LOG_HOME" value="D:/log/loggers" />
<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
</appender>
<!-- 按照每天生成日志文件 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--日志文件输出的文件名-->
<FileNamePattern>${LOG_HOME}/TestSpringBoot.log.%d{yyyy-MM-dd}.log</FileNamePattern>
<!--日志文件保留天数-->
<MaxHistory>30</MaxHistory>
</rollingPolicy>
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
<!--日志文件最大的大小-->
<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<MaxFileSize>10MB</MaxFileSize>
</triggeringPolicy>
</appender>
<!-- 日志输出级别 -->
<root level="INFO">
<appender-ref ref="STDOUT" />
<appender-ref ref="FILE" />
</root>
</configuration>
上面的配置文件中“D:/log/loggers"需要自己的保存日志的路径，然后启动服务，并到配置的路径文件夹中查看是否有日志 如下图
-接下来分级别配置日志（将日志分为info与error）
修改 logback.log 增加新的error appender 修改原来的appender 为 info
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
<property name="LOG_HOME" value="D:/log/logger" />
<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
</appender>
<!-- 按照每天生成日志文件 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--日志文件输出的文件名-->
<FileNamePattern>${LOG_HOME}/TestSpringBoot.log_info.%d{yyyy-MM-dd}.log</FileNamePattern>
<!--日志文件保留天数-->
<MaxHistory>30</MaxHistory>
</rollingPolicy>
<!--修改原来的 appender 为info 这个是第二步加上的 目的是让 info日志与error日志分开-->
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>info</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
<!--修改原来的 appender 为info 这个是第二步加上的 目的是让 info日志与error日志分开-->
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
<!--日志文件最大的大小-->
<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<MaxFileSize>10MB</MaxFileSize>
</triggeringPolicy>
</appender>
<!--新增加的error appender 这个是第二步加上的 目的是让 info日志与error日志分开-->
<appender name="DAYERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--日志文件输出的文件名-->
<FileNamePattern>${LOG_HOME}/error/TestSpringBoot_error.log.%d{yyyy-MM-dd}.log</FileNamePattern>
<!--日志文件保留天数-->
<MaxHistory>30</MaxHistory>
</rollingPolicy>
<!--这里设置日志级别为error-->
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>error</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
<!--日志文件最大的大小-->
<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<MaxFileSize>10MB</MaxFileSize>
</triggeringPolicy>
</appender>
<!--新增加的error appender 这个是第二步加上的 目的是让 info日志与error日志分开-->
<!-- 日志输出级别 -->
<root level="INFO">
<appender-ref ref="STDOUT" />
<appender-ref ref="FILE" />
</root>
</configuration>
配置后启动服务，生成如下图表示成功
这样配置日志初步完成！
》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
接下来整合mybatis
先添加pom文件
<!-- springboot 整合mybatis 依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.4</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!-- springboot 整合mybatis 依赖 -->
<!-- springboot 整合mybatis 依赖 正常是不需要加最后这个spring.tx的依赖的 但加上前两个后启动报错 所以要添加这个 如果正常添加前两个依赖没有报错 那这个可以忽略-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.3.18.RELEASE</version>
</dependency>
<!-- springboot 整合mybatis 依赖 正常是不需要加最后这个spring.tx的依赖的 但加上前两个后启动报错 所以要添加这个 如果正常添加前两个依赖没有报错 那这个可以忽略-->
接着在application.properties 中增加以下配置（也可以将application.properties改成application.yml 这两个配置文件功能相同 只不过后面这个将配置格式化 我使用的是后者） 配置数据库
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/shiro?useUnicode=true&characterEncoding=UTF-8
username: root
password: 123
接着在数据库创建表，与之前的user实体类对应，并添加几条数据，如下图
建表语句：
drop table IF EXISTS user;
create table user(
id BIGINT auto_increment primary key,
user_name varchar(20),
pass_word varchar(20),
create_time date,
mark varchar(20)
);
备注：正常是要先做数据库然后编写代码的，我这是测试就后写了
接着新建dao层，新建一个mapper接口
package com.zhanghui.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import com.zhanghui.entity.user;
@Mapper
public interface TestMapper {
@Select("SELECT * FROM user WHERE user_name = #{userName}")
user findByName(@Param("userName") String userName);
}
然后在service中新建一个方法并添加mapper的注入
package com.zhanghui.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.zhanghui.entity.user;
import com.zhanghui.mapper.TestMapper;
@Service
public class TestService {
public user getUser(){
return new user();
}
//注入dao层的mapper接口
@Autowired
private TestMapper testMapper;
//连接数据库方法
public user findByName(String userName){
return testMapper.findByName(userName);
}
}
接着在controller中添加方法
package com.zhanghui.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.zhanghui.entity.user;
import com.zhanghui.service.TestService;
@Controller
public class TestController {
//增加日志
private static final Logger LOGGER = LoggerFactory.getLogger(TestController.class);
@RequestMapping("/")
@ResponseBody
String home(){
return "hello world!";
}
//注入service类
@Autowired
private TestService testService;
//新加方法
@RequestMapping("/get")
@ResponseBody
public user getUser(){
//打印日志
LOGGER.info("此处添加日志！！");
return testService.getUser();
}
//连接数据库方法
@RequestMapping("/find")
@ResponseBody
public user findByName(){
//这个拉萨附近是我自己在数据库中添加的数据
return testService.findByName("拉萨附近");
}
}
启动服务并通过http://localhost:8080/find访问 返回下图表示成功
问题 ：这里出现了一个问题，就是返回值出现了空值
问题原因：是因为实体类的字段名与数据库的字段名不一样（我在实体类用了驼峰命名法） 所以返回空值
解决方法：
1.将实体类的字段名改成可数据库一样的就可以
2.在配置文件application.yml中加入开启驼峰命名法的配置
mybatis:
configuration:
map-underscore-to-camel-case: true #开启驼峰命名法
已经返回了数据库中的数据 表示添加mybatis成功！
》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
接下来添加swagger
首先在pom中添加依赖
<!--添加swagger依赖 -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.6.1</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.6.1</version>
</dependency>
<!--添加swagger依赖 -->
然后新建一个配置类：
package com.zhanghui.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
@Configuration
public class Swagger {
@Bean
public Docket createRestApi(){
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.zhanghui.controller")) //这里要配置自己的controller的包名 否则swagger不会显示方法
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
// TODO 自动生成的方法存根
return new ApiInfoBuilder()
//页面标题
.title("Course 项目 API 开发文档")
//创建人
.contact(new Contact("啦啦啦 假的 假的 假的", "http://www.wangzijiang.cn", "123@qq.com"))
//描述
.description("简单优雅的restfun风格")
//服务条款URL
.termsOfServiceUrl("http://blog.csdn.net")
//版本号
.version("1.0")
.build();
}
}
接着在服务启动类中加入swagger的注解
package com.zhanghui;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@SpringBootApplication
@EnableSwagger2 //swagger注解
public class SpringbootDemoTestApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemoTestApplication.class, args);
}
}
接着在dao层中的mapper类的添加方法
package com.zhanghui.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import com.zhanghui.entity.user;
@Mapper
public interface TestMapper {
@Select("SELECT * FROM user WHERE user_name = #{userName}")
user findByName(@Param("userName") String userName);
//添加swagger测试方法
@Select("SELECT * FROM user")
List<com.zhanghui.entity.user> selectAll();
}
接着在service中添加方法
package com.zhanghui.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.zhanghui.entity.user;
import com.zhanghui.mapper.TestMapper;
@Service
public class TestService {
public user getUser(){
return new user();
}
//注入到层的mapper接口
@Autowired
private TestMapper testMapper;
//连接数据库方法
public user findByName(String userName){
return testMapper.findByName(userName);
}
//添加swagger测试方法
public List<user> selectAll() {
// TODO 自动生成的方法存根
List<user> user = testMapper.selectAll();
return user;
}
}
接着在controller中添加方法
注意：这里要将之前的@RequestMapping注解改成 @GetMapping /@PostMapping /@PutMapping /@DeleteMapping 之中的一个，不然会出现 每个方法在swagger中都显示4个 增删改查都有
package com.zhanghui.controller;
import io.swagger.annotations.ApiOperation;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.zhanghui.entity.user;
import com.zhanghui.service.TestService;
@Controller
public class TestController {
//增加日志
private static final Logger LOGGER = LoggerFactory.getLogger(TestController.class);
@GetMapping("/")
@ResponseBody
String home(){
return "hello world!";
}
//注入service类
@Autowired
private TestService testService;
//新加方法
@GetMapping("/get")
@ResponseBody
public user getUser(){
//打印日志
LOGGER.info("此处添加日志！！");
return testService.getUser();
}
//连接数据库方法
@GetMapping("/find")
@ResponseBody
public user findByName(){
return testService.findByName("拉萨附近");
}
//添加swagger测试方法
@ApiOperation(value="获取用户列表", notes="获取用户列表")
@GetMapping("//getAll")
@ResponseBody
public List<user> getAll(){
return testService.selectAll();
}
}
添加完成后启动服务，并访问 http://localhost:8080/swagger-ui.html 出现下图表示成功！
然后点开test_ontroller 进入里面的方法 并测试swagger！
这个返回值为空的问题在上面已经解答！ 添加驼峰命名法的配置
这样添加swagger，简单配置完成！
》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
接下来添加通用mapper与分页插件
添加通用mapper 依赖
<!--分页插件-->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>4.1.1</version>
</dependency>
<!--通用Mapper-->
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<!-- 下面这个依赖可以使用 @getter @setter 注解 正常整合通用mapper只要添加上面两个依赖就可以了 下面这个依赖是我要改变user实体类需要的 这样实体类中就可以不用添加 getset方法而改用使用注解-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
接下来改变user实体类
package com.zhanghui.entity;
import java.util.Date;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import com.fasterxml.jackson.annotation.JsonFormat;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString
@Builder
@Table(name="user")
public class user {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String userName;
private String passWord;
@JsonFormat
private Date createTime;
private String mark;
}
补充 ---- 上面这个实体类也可以写成下面这样 @Data 可以代替其他的注解
package com.zhanghui.entity;
import java.util.Date;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import lombok.Data;
import com.fasterxml.jackson.annotation.JsonFormat;
@Data
@Table(name="user")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String userName;
private String passWord;
@JsonFormat
private Date createTime;
private String mark;
}
================================================================================================
接下来创建mapper接口的父类
package com.zhanghui.config;
import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;
public interface MyMapper<T> extends Mapper<T>, MySqlMapper<T> {
//TODO
//FIXME 特别注意，该接口不能被扫描到，否则会出错
//通用mapper,注意:这个mapper不能和其它mapper放在一起
//* 也就是不能被Mybatis扫描到
/* 下面这个注释是我在我网上找的 ---仅供阅读---
* 创建BaseMapper:通过源码可以看到这些接口的顶级接口最后又被分为增删改查四大类,
* 所以上面的StudentMapper通过继承BaseMapper,就间接实现了这些通用的增删改查接口。
* 当然这一部分接口不需要你自己实现,所以它不能和其它的mapper放在一起,
* 以免被@MapperScan("com.*.Mapper")扫描到,Mybatis扫描后发现你实现了这么多接口但是在
* 映射文件却一个也没有实现,这时候就会报错。但是这些接口一定要被
* 通用Mapper的MapperScan扫描到,由它来根据你在实体类与表中配关系生成通用
* 的增删改查方法
* */
}
接下来在配置文件中添加配置
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/shiro?useUnicode=true&characterEncoding=UTF-8
username: root
password: 123
jackson:
date-format: java.text.SimpleDateFormat
time-zone: GMT+8
# 配置通用mapper 将原来写入类中的参数 配置到这里
mybatis:
type-aliases-package: com.zhanghui.entity #实体类的包所在
mapper-locations: classpath:mapper/*.xml #mapper类对应的mapper.xml
mappers: com.zhanghui.MyMapper #mapper的父类 自己写的那个通用mapper
identity: MYSQL #
table:
auto: update
model:
pack: com.zhanghui.entity
database:
type: mysql
configuration:
map-underscore-to-camel-case: true #开启驼峰命名法
#分页插件配置
pagehelper:
helperDialect: mysql
reasonable: true
supportMethodsArguments: true
params: count=countSql
将dao层新建mapper类并继承mapper父类
package com.dexcoder.mapper;
import org.springframework.stereotype.Component;
import com.dexcoder.config.MyMapper;
import com.dexcoder.entity.User;
@Component
public interface UserMapper extends MyMapper<User>{
}
接下来在启动类中添加注解
package com.zhanghui;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
import tk.mybatis.spring.annotation.MapperScan;
@MapperScan(basePackages = "com.zhanghui.mapper")
@SpringBootApplication
@EnableSwagger2
public class SpringbootDemoTestApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemoTestApplication.class, args);
}
}
接下来在service中添加方法
package com.zhanghui.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.zhanghui.entity.User;
import com.zhanghui.mapper.TestMapper;
import com.zhanghui.mapper.UserMapper;
@Service
public class TestService {
public User getUser(){
return new User();
}
//注入到层的mapper接口
@Autowired
private TestMapper testMapper;
//连接数据库方法
public User findByName(String userName){
return testMapper.findByName(userName);
}
//添加swagger测试方法
public List<User> selectAll() {
// TODO 自动生成的方法存根
List<User> user = testMapper.selectAll();
return user;
}
//添加测试通用mapper
@Autowired
private UserMapper userMapper;
public List<User> getUserMapper(){
return userMapper.selectAll();
}
}
接下来添加controller方法
package com.zhanghui.controller;
import io.swagger.annotations.ApiOperation;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.zhanghui.entity.User;
import com.zhanghui.service.TestService;
@Controller
public class TestController {
//增加日志
private static final Logger LOGGER = LoggerFactory.getLogger(TestController.class);
@GetMapping("/")
@ResponseBody
String home(){
return "hello world!";
}
//注入service类
@Autowired
private TestService testService;
//新加方法
@GetMapping("/get")
@ResponseBody
public User getUser(){
//打印日志
LOGGER.info("此处添加日志！！");
return testService.getUser();
}
//连接数据库方法
@GetMapping("/find")
@ResponseBody
public user findByName(){
return testService.findByName("拉萨附近");
}
//添加swagger测试方法
@ApiOperation(value="获取用户列表", notes="获取用户列表")
@GetMapping("//getAll")
@ResponseBody
public List<User> getAll(){
return testService.selectAll();
}
//添加测试通用mapper
@ApiOperation(value="获取用户列表,234测试通用mapper", notes="获取用户列表,234测试通用mapper")
@GetMapping("/qureyUser")
@ResponseBody
public List<User> getUserMapper(){
return testService.getUserMapper();
}
}
启动服务，并访问http://localhost:8080/swagger-ui.html 出现下图表示成功！
这次可以返回实体类了，上面的返回空的问题有待解决！
通用mapper添加成功！
错误描述：添加完通用mapper配置后，启动项目，当访问数据库时出现错误
java.lang.NoSuchMethodException: tk.mybatis.mapper.provider.base.BaseSelectProvider.<init>()
解决办法：我的是因为倒包错误（注意倒包是一定要看一下 默认导入的是org的包）
@MapperScan导入包错误，将import org.mybatis.spring.annotation.MapperScan 改成import tk.mybatis.spring.annotation.MapperScan;
网上还有说是其他错误的 比如：
.jar包冲突 如下面所示这里有两个tk.mybatis通用Mapper的包了，所以springboot不知道该初始化哪个
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper</artifactId>
<version>3.3.9</version>
</dependency>
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
MapperCan 扫包配置错误 ：
之前配置的是
@MapperScan(basePackages = "com.example.demo.*.dao")
应该改成
@MapperScan(basePackages = "com.example.demo.*.dao.*")
》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
接下来添加定时任务
首先在启动类中添加注解@EnableScheduling
package com.zhanghui;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
import tk.mybatis.spring.annotation.MapperScan;
@MapperScan(basePackages = "com.zhanghui.mapper")
@SpringBootApplication
@EnableSwagger2
@EnableScheduling
public class SpringbootDemoTestApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemoTestApplication.class, args);
}
}
在新建类中添加一个定时任务
package com.zhanghui.scheduling;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
public class SchedulingTest {
private static final Logger LOGGER = LoggerFactory.getLogger(SchedulingTest.class);
//定时任务 5秒执行一次
@Scheduled(cron = "0/5 * * * * ?")
public void scheduler(){
LOGGER.info(">>>>>>>>>>>>>>>>>>>>>>>>>scheduled test .....");
}
}
启动服务，在控制台输出入下图表示成功！
定时任务完成！
》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
接下来添加事物
首先添加依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
在数据库新建表user_role
drop table IF EXISTS user_role;
create table user_role(
id BIGINT auto_increment primary key,
user_id BIGINT(20),
role_id BIGINT(20),
status INTEGER(2)
);
新建一个实体类
package com.zhanghui.entity;
import javax.persistence.Table;
import lombok.Data;
@Data
@Table(name="user_role")
public class UserRole {
private Long id;
private Long userId;
private Long roleId;
private Integer status;
}
新建一个mapper
package com.zhanghui.mapper;
import org.apache.ibatis.annotations.Mapper;
import com.zhanghui.config.MyMapper;
import com.zhanghui.entity.UserRole;
@Mapper
public interface UserRoleMapper extends MyMapper<UserRole>{
}
在TestService中，添加方法
注意不要忘记添加事物的注解
//添加新增方法 并测试事物
@Transactional
public int addUser(User user) {
// TODO 自动生成的方法存根
int i = testMapper.insert(user);
System.out.println(user.getId());
int ss = addRole(user.getId());
System.out.println("sssss==" + ss);
//注意下面这两行是报错的 为了测试事物是否可用 正常添加时需要把这个去掉
/*List list = new ArrayList<User>();
list.get(0);*/
//或者使用下面这种方式 抛出异常
if (true) {
throw new RuntimeException("save 抛异常了");
}
return i;
}
@Autowired
private UserRoleMapper userRoleMapper;
public int addRole(Long id){
UserRole record = new UserRole();
record.setStatus(1);
record.setUserId(id);
record.setRoleId(id);
int i = userRoleMapper.insertSelective(record);
return i;
}
在TestController中添加方法
//添加新增方法 并测试事物
@ApiOperation(value = "添加新增用户方法 并测试事物",notes = "添加新增用户方法 并测试事物")
@PostMapping("/test/add")
@ResponseBody
public int addUser(User user){
return testService.addUser(user);
}
启动服务并访问http://localhost:8080/swagger-ui.html 然后在方法中找到新添加的方法
然后这样运行后台会报500 到数据库里查看数据没有添加上！
到此 简单的添加事物注解@Transactional成功！
》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》
3053
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
