springboot + mybatis + 一整套项目的整合 (这几天公司没什么事，自己打了个框架)

做为转行过来的半路程序猿，需要学的还是很多。虽然工作了两年了，但是基本上都是项目经理搭好框架，我只负责写代码。纯粹的code,最近公司没什么事，就想着要不干点别的，自己就想去做个小网站玩玩。思前想后决定用springboot+mybatis+maven 做。如果哪里有不对的的地方请指出。闲话不多说开始搭建项目

首先，开发环境。（题外话，这里就不讲怎么安装maven eclipse了。网上有好多安装也很简单，这里只讲怎么搭建一个完整的项目）

1. java语言  eclipse ,mysql5.6 ,jdk7,window

2.先上我的项目结构目录，这样有需要参考的朋友可以先清楚目录结构

，这里说下我踩过的坑，我以前没用过springboot,对这个东西不是很了解。做的过程中我也没有去看官方文档，全英文，你们懂得为什么不去看了，（实在是看不懂，）。

1.我的项目目录是org.dz.testspringboot.demo   这个其实也有讲究的。org在有个明文规定，项目以org包开头就是开源的，还有什么com就是有公司版权的等。至于后面的dz自己可以写自己的标识。

2、用eclispse创建boot项目，src/main/resources下面的文件要自己创建，优先级顺序为：META/resources > resources > static > public   就是说这些目录下面有相同的资源的时候，http://localhost:8080/相同资源文件，优先顺序就是上面写的

3.下来就说这个全局的启动类，Application  这个类一定是在最外层和controller等在同一层。只有这样启动的时候才能全扫描所有的文件

package org.dz.testSpringBoot.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableAutoConfiguration
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}

}

现在开始一次性先把文件目录创建出来

controller,这次存放的是我们的是我们的逻辑控制层的代码

service,存放的是我们的业务层逻辑代码 ，由于有些业务不能对外访问，所以我们需要建立对方访问的接口。接口就需要他的实现类，在里面创建一个imp文件，这里放的就是我们对外开放的业务层实现接口访问。

dao，就是我们的数据访问层代码。

entity,就是我们实体类的存放文件。

basedao,mybatis  大家都知道我们查询数据库的时候，查询的数据要做分页处理。这里就是我们查询分页的代码

现在就一次贴出里面的代码

controller里面的代码

package org.dz.testSpringBoot.demo.controller;
import java.util.List;
import java.util.Map;
import org.dz.testSpringBoot.demo.entity.User;
import org.dz.testSpringBoot.demo.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
@RequestMapping("user")
public class UserController {
//添加日志
private final Logger logger = LoggerFactory.getLogger(UserController.class);
@Autowired
private UserService userService;

@RequestMapping("/")
public int home() {
int i = userService.testUserService();
return i;
}
/**
* 
* @Title: getInfo
* @Description:这里是跳转到index页面  
* @param @param map
* @param @return      
* @return String    
* @throws
*/
@RequestMapping(value="/index")
public String getInfo(Map<String,Object> map) {

map.put("aaa", "bbbbb");
return "index";
}
/**
* @Title: getInfo
* @Description:这里是访问add页面的，也就是提交表单页面 
* @param @param model
* @param @return      
* @return String    
* @throws
*/
@RequestMapping(value="/submit")
public String getInfo(Model model) {
model.addAttribute("user", new User());
return "add";
}
/**
* @Title: getUser
* @Description:从数据库中获取这个对象  
* @param @return      
* @return User    
* @throws
*/
@RequestMapping("/get")
@ResponseBody
public User getUser() {
logger.info("获取到人员信息");
return userService.testUser();

}
/**
* @Title: insertUser
* @Description:这里是add页面提交数据后保存数据 
* @param @param user
* @param @return      
* @return String    
* @throws
*/
@PostMapping("/add")
public String insertUser(@ModelAttribute User user ) {
logger.info("保存人员信息");
userService.insertUser(user.getUsername(), user.getPassword());
user.setPassword("修改密码");
user.setUsername("宋森");
user.setUserId("1111");
return "view";

}
/**
* @Title: getall
* @Description:从数据库中获取这个对象的所有数据 
* @param @return      
* @return List<User>    
* @throws
*/
//新增的接口方法
    @RequestMapping("/getall")
    @ResponseBody List<User> getall() {
        return userService.selectALL();
    }

}

dao层代码

package org.dz.testSpringBoot.demo.dao;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.dz.testSpringBoot.demo.dao.basedao.MyMapper;
import org.dz.testSpringBoot.demo.entity.User;
@Mapper
public interface UserDao extends MyMapper<User> {
@Select("SELECT * FROM USERINFO WHERE username = #{username}")
    public User findByName(@Param("username") String username);

    @Insert("INSERT INTO USERINFO(username, password) VALUES(#{username}, #{password})")
   public int insertUser(@Param("username") String name, @Param("password") String password);

}

dao.basedao中的代码

package org.dz.testSpringBoot.demo.dao.basedao;
import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;
public interface MyMapper<T> extends Mapper<T>,MySqlMapper<T> {

}

dao.mybatis  这里就是我们mybatis查询分页用到的 是自带的分页工具类

package org.dz.testSpringBoot.demo.dao.mybatis;
import java.util.Properties;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.annotation.Bean;
import com.github.pagehelper.PageHelper;
public class MyBatisConfig {
@Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactoryBean() {

    SqlSessionFactoryBean bean = new SqlSessionFactoryBean();

//我这里是让扫描实体所在的文件，你也可以在实体上加上@Entity这个注解，这个我还没有研究出来，大家先按照我这个做

    bean.setTypeAliasesPackage("org.dz.testSpringBoot.demo.entity");
    //分页插件设置
    PageHelper pageHelper = new PageHelper();
    Properties properties = new Properties();
    properties.setProperty("reasonable", "true");
    properties.setProperty("supportMethodsArguments", "true");
    properties.setProperty("returnPageInfo", "check");
    properties.setProperty("params", "count=countSql");
    pageHelper.setProperties(properties);
    //添加分页插件

    bean.setPlugins(new Interceptor[]{pageHelper});

//这里你如果用的是配置文件  这里就需要扫描配置文件让mybatis加载配置文件，我用的是注解所有我把它注掉了

//     ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    try {
        //基于注解扫描Mapper，不需配置xml路径
        //bean.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
        return bean.getObject();
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
    }

}

package org.dz.testSpringBoot.demo.dao.mybatis;
import java.util.Properties;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import tk.mybatis.spring.mapper.MapperScannerConfigurer;
@Configuration
//必须在MyBatisConfig注册后再加载MapperScannerConfigurer，否则会报错
@AutoConfigureAfter(MyBatisConfig.class)
public class MyBatisMapperScannerConfig {
@Bean
public MapperScannerConfigurer mapperScannerConfigurer() {
MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
mapperScannerConfigurer.setBasePackage("org.dz.testSpringBoot.demo.dao.mybatis");
//初始化扫描器的相关配置，这里我们要创建一个Mapper的父类
    Properties properties = new Properties();
    properties.setProperty("mappers", "org.dz.testSpringBoot.demo.dao.basedao.MyMapper");
    properties.setProperty("notEmpty", "false");
    properties.setProperty("IDENTITY", "MYSQL");
    mapperScannerConfigurer.setProperties(properties);
    return mapperScannerConfigurer;
}

}

entity中的代码 这个没什么好讲的，稍微懂点的同学都知道

package org.dz.testSpringBoot.demo.entity;
import javax.persistence.Column;
import javax.persistence.Table;
@Table(name="userinfo")
public class User {
@Column(name="userId")
private String userId;
@Column(name="username")
private String username;
@Column(name="password")
private String password;
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
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;
}
@Override
public String toString() {
return "User{" + "username='" + username + '\'' + ", password='" + password + '\'' + '}';
}

}

service下面的代码 这个接口就是对外访问的，逻辑我们肯定是不能让别人知道的，所以我们要有自己的实现类

package org.dz.testSpringBoot.demo.service;
import java.util.List;
import org.dz.testSpringBoot.demo.entity.User;
public interface UserService {
public int testUserService();
public User testUser();
//存储对象的，由于是一个简单的框架，我做的是插入表，最简单的方法，这里后期还需要修改，肯定是要封装一个方法，直接存储一个前台传过来的对象
public int insertUser(String username,String password);
//查询所有的数据
    List<User> selectALL();

}

service.imp下面的代码  这里就是我们业务层实现类，这里面的实现方法肯定不能对外访问了，这里我们只要实现对外访问的接口就可以

package org.dz.testSpringBoot.demo.service.imp;
import java.util.List;
import org.dz.testSpringBoot.demo.dao.UserDao;
import org.dz.testSpringBoot.demo.entity.User;
import org.dz.testSpringBoot.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImplement implements UserService {
@Autowired 
private UserDao userDao;
@Override
public int testUserService() {
return 0;
}
@Override
public User testUser() {
 
return new User();
}
@Override
public int insertUser(String username, String password) {
return userDao.insertUser(username, password);
}
@Override
public List<User> selectALL() {
return userDao.selectAll();
}

}

现在我们整个控制层，业务层，数据库访问层的全部代码已经贴出来了。接下来就是我们主要的配置文件了，这是比较重要的部分。

application.properties 这个文件就是springboot默认访问外部资源配置的地方 我这个项目没有什么好配置的，所以就只有一个数据库配置信息

#mysql

# 这个端口是因为我本地有多个项目要用到不同的数据库，所以我启动了两个mysql服务，这样就可以访问不同的数据库链接。

#最后我会把开启多个mysql服务粘贴出来

spring.datasource.url=jdbc:mysql://localhost:3356/test1 
spring.datasource.username=这里写自己数据库的登录名
spring.datasource.password=这里是密码

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

logback.xml 这里存放的是日志的配置   项目肯定要有日志记录的。我配置了彩色的日志输出，但是eclipse没有起作用。但是不影响我们使用。这里贴出来格式有点乱是因为这个文本行宽限制的，大家如果要用可以复制后在自己的项目中调整下
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径 这里是日志打印后默认储存的位置，如果不配这里他默认在C盘，大家都知道C盘是比较危险的一个地方，所以我把他放在别的盘-->
<property name="LOG_HOME" value="E:/log" /> 
<!-- 彩色日志 -->
    <!-- 彩色日志依赖的渲染类 -->
<conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />
    <!-- Console 输出设置 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <charset>utf8</charset>
        </encoder>
    </appender>
<!-- 控制台输出 -->
<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="DAYINFO"  class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <FileNamePattern>${LOG_HOME}/TestSpringBoot_info.log.%d{yyyy-MM-dd}.log</FileNamePattern>
            <!--日志文件保留天数-->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
        <!--这里设置日志级别为info-->
        <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-->
    <appender name="DAYERROR"  class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--日志文件输出的文件名-->
            <FileNamePattern>${LOG_HOME}/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>
    
<!-- 日志输出级别 -->
<root level="INFO">
<appender-ref ref="STDOUT" />
<appender-ref ref="DAYINFO" />
<appender-ref ref="DAYERROR" />
</root>
</configuration>

这里就是重要的pom配置文件了，这个文件中是我们项目中所用的包都需要在这里加载，这就是maven的特性，不需要很多的配置文件

<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>
<groupId>ogr.dz</groupId>
<artifactId>testSpringBoot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- Spring boot 父引用 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.8.RELEASE</version>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.7</java.version>
</properties>
<!-- Spring boot 核心包 -->
<dependencies>
<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>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency>
<!-- mysql所用的包 -->
<dependency> 
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.46</version>
    <scope>runtime</scope>
</dependency>
<!-- jdbc所用的包 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
</dependency>
<!--分页插件-->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>4.2.1</version>
</dependency>
<!--通用Mapper-->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper</artifactId>
    <version>3.3.9</version>
</dependency>
<dependency>  
<groupId>javax.servlet</groupId>  
<artifactId>jstl</artifactId>  
</dependency>
<!-- 这个包是为了能够访问templates下面的页面要用的 因为public static 这些文件夹下的html页面可以直接访问的 有些页面不想让别人直接访问就需要权限，就需要这个配置了 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

上面就是整个项目的所有代码和配置文件信息。由于用的是springboot 所以就用不到jsp页面了，所以我这里没有配置jsp的配置，如果需要的话，大家可以在网上找找，找到后可以直接发给我，我也可以参考参考 。[email protected]。

下来就是我上面说的如何在本地启动两个mysql服务

其实很简单。把你安装的mysql包复制一份 最好以你想设置的端口为末尾数。

下来就是要把mysql里面的你自己定义的ini文件里面的端口开成你自己要重新设置的端口。我自己定义的my.ini

用管理员身份启动cmd 进入到复制的mysql文件的bin目录下，安装服务 mysqld -install mysql3356   启动服务 net start mysql3356   这样你在服务中就可以看到启动了两个mysql服务 。下来再用你原来的root帐户在mysql的视图画工具中创建新的连接，注意端口是你改过之后的。里面会有你原端口的连接库里面的表，这里面你是可以随便删除的不会影响到你原端口中的表数据，注意几个mysql默认的表是不能删除的。这个基本上程序员应该都用。

到这里就一个完整的简单的项目就完成了。再次做一次记录。剩下就是小伙伴们可以在这个基础上加以改造，适合自己用的