springboot系列（一）集成mybatis

最新推荐文章于 2024-04-21 06:08:26 发布

LL小蜗牛

最新推荐文章于 2024-04-21 06:08:26 发布

阅读量185

点赞数

分类专栏： java web

本文链接：https://blog.csdn.net/weixin_37703281/article/details/82857818

版权

java web 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

springboot在我的理解的话，就是可以使整合主流框架更简单的一个集合框架，而且会使得部署，配置更为简单，并且有内嵌的servlet容器，可以快速地开发一个简单的应用，但是缺点的话也会有，因为高度集成了，所以一出bug，问题会比较难排查，这篇文章写的相对详细，可以看看https://blog.csdn.net/fly_zhyu/article/details/76407830。

然后开始编写代码：

准备工具：idea，maven，jdk1.8。

file->new project,选择Spring Initializr，然后一步步操作

然后我们这个是web项目，并且要集成mybatis和mysql,但后来会发现mysql的scope是runtime的，要把它去掉。记得要配置好本地的maven路径，ctrl+alt+s进行设置，

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>

	<groupId>com.csdn</groupId>
	<artifactId>demospringboot</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>demospringboot</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.5.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.5.2</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.yeauty</groupId>
			<artifactId>netty-websocket-spring-boot-starter</artifactId>
			<version>0.6.3</version>
		</dependency>
		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>1.3.2</version>
		</dependency>
	</dependencies>

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


</project>

首先看他的结构，DemospringbootApplication是我们这个程序的主入口，并且static用来存放静态资源，templates文件夹则用来存放模板文件，application.properties则是项目的配置文件，也可以用yml的格式来写。这个配置文件具体的配置可以看这篇文章，只需要编写一个controller，然后启动入口类，访问相应路径就可以看到效果了，注意要把mybatis的引入去掉，不然导致启动失败

然后现在要集成mybatis，开始配置，如果是主从配置即多数据源可以参考这篇文章：

这时候的application.properties文件内容如下：

server.port=8080
#mysql
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&rewriteBatchedStatements=TRUE
jdbc.username=root
jdbc.password=123456

#Mybatis
mapper_path=/mapper/**.xml
type_alias_package=com.csdn.demospringboot.entity

#Redis配置
redis.hostname=127.0.0.1
redis.port=6379
redis.pool.maxActive=100
redis.pool.maxIdle=20
redis.pool.maxWait=3000
redis.pool.testOnBorrow=true
redis.password=123456
redis.timeout=3000

#websocket
netty-websocket.host=0.0.0.0
netty-websocket.path=/
netty-websocket.port=8083



spring.mvc.view.prefix=/html/
spring.mvc.view.suffix=.html

DataSourceConfiguration:

package com.csdn.demospringboot.config.dao;

import org.springframework.context.annotation.Configuration;

import java.beans.PropertyVetoException;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


import com.mchange.v2.c3p0.ComboPooledDataSource;

/**
 * 配置datasource到ioc容器里面
 *
 * @author xiangze
 *
 */
@Configuration
// 配置mybatis mapper的扫描路径
@MapperScan("com.csdn.demospringboot.dao")
public class DataSourceConfiguration {
    @Value("${jdbc.driver}")
    private String jdbcDriver;
    @Value("${jdbc.url}")
    private String jdbcUrl;
    @Value("${jdbc.username}")
    private String jdbcUsername;
    @Value("${jdbc.password}")
    private String jdbcPassword;

    /**
     * 生成与spring-dao.xml对应的bean dataSource
     *
     * @return
     * @throws PropertyVetoException
     */
    @Bean(name = "dataSource")
    public ComboPooledDataSource createDataSource() throws PropertyVetoException {
        // 生成datasource实例
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        // 跟配置文件一样设置以下信息
        // 驱动
        dataSource.setDriverClass(jdbcDriver);
        // 数据库连接URL
        dataSource.setJdbcUrl(jdbcUrl);
        // 设置用户名
        dataSource.setUser(jdbcUsername);
        // 设置用户密码
        dataSource.setPassword(jdbcPassword);
        // 配置c3p0连接池的私有属性
        // 连接池最大线程数
        dataSource.setMaxPoolSize(30);
        // 连接池最小线程数
        dataSource.setMinPoolSize(10);
        // 关闭连接后不自动commit
        dataSource.setAutoCommitOnClose(false);
        // 连接超时时间
        dataSource.setCheckoutTimeout(10000);
        // 连接失败重试次数
        dataSource.setAcquireRetryAttempts(2);
        //设置连接池存活时间,可以根据数据库的配置进行更改。
        dataSource.setMaxIdleTime(3600);
        return dataSource;
    }

}

@Value是用来读取配置文件的信息，如果要注入的字段是静态的，就为该字段生成一个静态的setter方法，并且@Value放在这个setter方法上进行注入。@Bean就是说明这个类交由spring容器管理。

SessionFactoryConfiguration:

package com.csdn.demospringboot.config.dao;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

import javax.sql.DataSource;
import java.io.IOException;
@Configuration
public class SessionFactoryConfiguration {

    private static String mapperPath;

    @Value("${mapper_path}")
    public void setMapperPath(String mapperPath) {
        SessionFactoryConfiguration.mapperPath = mapperPath;
    }
    @Value("${type_alias_package}")
    private String typeAliasPackage;
    @Autowired
    //因为这里有两个dataSource，要指定我们配置好的那一个
    @Qualifier("dataSource")
    private DataSource dataSource;

    @Bean(name="sqlSessionFactory")
    public SqlSessionFactoryBean createSqlSessionFactoryBean() throws IOException {
        //建立会话工厂
        SqlSessionFactoryBean sqlSessionFactoryBean=new SqlSessionFactoryBean();
        //配置mybatis,对应mybatis-config.xml
        org.apache.ibatis.session.Configuration configuration=new org.apache.ibatis.session.Configuration();
        //使用jdbc的getGeneratedKeys获取数据库自增主键值
        configuration.setUseGeneratedKeys(true);
        //使用列别名替换列名 select user as User
        configuration.setUseColumnLabel(true);
        //-自动使用驼峰命名属性映射字段   userId    user_id
        configuration.setMapUnderscoreToCamelCase(true);
        sqlSessionFactoryBean.setConfiguration(configuration);
        // 添加mapper 扫描路径
        //PathMatchingResourcePatternResolver可以用来解析资源文件,主要是用来解析类路径下的资源文件
        PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver();
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + mapperPath;
        sqlSessionFactoryBean.setMapperLocations(pathMatchingResourcePatternResolver.getResources(packageSearchPath));
        // 设置dataSource
        sqlSessionFactoryBean.setDataSource(dataSource);
        // 设置typeAlias 包扫描路径
        sqlSessionFactoryBean.setTypeAliasesPackage(typeAliasPackage);
        return sqlSessionFactoryBean;
    }
}

这下我们基本完成了dao层的配置，接下来我们可以在test文件夹新建一个测试类，

但先在数据库建立一个user表

CREATE TABLE `tb_user` (
  `user_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(255) NOT NULL,
  `user_password` varchar(255) NOT NULL,
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

然后建立相应的实体类User,写好属性后，可以按alt+insert生成get,set方法。

package com.csdn.demospringboot.entity;

public class User {
    private Integer userId;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserPassword() {
        return userPassword;
    }

    public void setUserPassword(String userPassword) {
        this.userPassword = userPassword;
    }

    private String userName;
    private String userPassword;
}

然后我们在test目录下新建一个测试类：

package com.csdn.demospringboot.dao;

import com.csdn.demospringboot.DemospringbootApplication;
import com.csdn.demospringboot.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.PropertySource;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

import static org.junit.Assert.*;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = DemospringbootApplication.class)
@EnableAutoConfiguration
public class UserDaoTest {
    @Autowired
    private UserDao userDao;
    @Test
    public void insertUser() throws Exception {
        User user=new User();
        user.setUserName("user1");
        user.setUserPassword("pwd1");
        assertEquals(1,userDao.insertUser(user));
    }

    @Test
    public void deleteUser() throws Exception {
        List<User> userList=userDao.queryAllUser();
        assertEquals(1,userDao.deleteUser(userList.get(0).getUserId()));
    }



    @Test
    public void queryAllUser() throws Exception {

    }

    @Test
    public void queryUserById() throws Exception {

    }

}

执行insertUser方法，可以看到数据库里面已有数据，然后我们再配置service层，web层，service层主要是一个事务管理的配置，注意配置类的，都要加@Configuration这个注解作为加载时的配置。

package com.csdn.demospringboot.config.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;

import javax.sql.DataSource;
@Configuration
@EnableTransactionManagement
public class TransactionManagementConfiguration implements TransactionManagementConfigurer {
    @Autowired
    @Qualifier("dataSource")
    private DataSource dataSource;
    @Override
    public PlatformTransactionManager annotationDrivenTransactionManager() {
        return new DataSourceTransactionManager(dataSource);
    }
}

web层的配置，主要是用来定义视图解析器，限制文件上传大小，配置拦截器等等

package com.csdn.demospringboot.config.web;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
@Configuration
public class MvcConfiguration implements WebMvcConfigurer,ApplicationContextAware  {
    // Spring容器
    private ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
 /*   @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
         registry.addResourceHandler("/resources/**").addResourceLocations("classpath:/resources/");
    }*/
    /*
    文件上传解析
     */
    @Bean(name = "multipartResolver")
    public CommonsMultipartResolver createMultipartResolver() {
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
        multipartResolver.setDefaultEncoding("utf-8");
        // 1024 * 1024 * 20 = 20M
        multipartResolver.setMaxUploadSize(20971520);
        multipartResolver.setMaxInMemorySize(20971520);
        return multipartResolver;
    }



  /*
   @Autowired
   拦截器
  @Override
    public void addInterceptors(InterceptorRegistry registry){
        registry.addInterceptor(拦截器).addPathPatterns("路径");
    }*/

}

接下来就是正常的一个service,controller层的代码编写，也可以简单地用一下restful风格去编写controller代码，至此整合完毕