eclipse 使用maven 搭建 springboot+mybatis + 多数据源

最新推荐文章于 2024-05-19 10:45:02 发布
最新推荐文章于 2024-05-19 10:45:02 发布
阅读量4.3k 收藏 2
点赞数
分类专栏： 微服务springboot

本文转载至：http://www.cnblogs.com/java-zhao/p/5413845.html

在实际开发中，我们一个项目可能会用到多个数据库，通常一个数据库对应一个数据源。

代码结构：


简要原理：

1）DatabaseType列出所有的数据源的key---key

2）DatabaseContextHolder是一个线程安全的DatabaseType容器，并提供了向其中设置和获取DatabaseType的方法

3）DynamicDataSource继承AbstractRoutingDataSource并重写其中的方法determineCurrentLookupKey()，在该方法中使用DatabaseContextHolder获取当前线程的DatabaseType

4）MyBatisConfig中生成2个数据源DataSource的bean---value

5）MyBatisConfig中将1）和4）组成的key-value对写入到DynamicDataSource动态数据源的targetDataSources属性（当然，同时也会设置2个数据源其中的一个为DynamicDataSource的defaultTargetDataSource属性中）

6）将DynamicDataSource作为primary数据源注入到SqlSessionFactory的dataSource属性中去，并且该dataSource作为transactionManager的入参来构造DataSourceTran



sactionManager

7）使用的时候，在dao层或service层先使用DatabaseContextHolder设置将要使用的数据源key，然后再调用mapper层进行相应的操作，建议放在dao层去做（当然也可以使用spring aop+自定注解去做）

注意：在mapper层进行操作的时候，会先调用determineCurrentLookupKey()方法获取一个数据源（获取数据源：先根据设置去targetDataSources中去找，若没有，则选择defaultTargetDataSource），之后在进行数据库操作。

1、系统配置文件application.properties

#the read datasource
jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://127.0.0.1:3306/master?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8
jdbc.username = test
jdbc.password = 123456

#the write datasource
jdbc2.driverClassName = com.mysql.jdbc.Driver
jdbc2.url = jdbc:mysql://127.0.0.1:3306/master?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8
jdbc2.username = root
jdbc2.password = 123456

mybatis.typeAliasesPackage=com.zzg.myboot.domain  
mybatis.mapperLocations=classpath:mapper/*.xml


2、DatabaseType

package com.zzg.myboot.datasource;

/**
 * 列出所有的数据源key（常用数据库名称来命名）
 * 注意：
 * 1）这里数据源与数据库是一对一的
 * 2）DatabaseType中的变量名称就是数据库的名称
 */
public enum DatabaseType {
    read,write
}

作用：列举数据源的key。

3、DatabaseContextHolder

package com.zzg.myboot.datasource;

/**
 * 作用：
 * 1、保存一个线程安全的DatabaseType容器
 */
public class DatabaseContextHolder {
    private static final ThreadLocal<DatabaseType> contextHolder = new ThreadLocal<DatabaseType>();
    
    public static void setDatabaseType(DatabaseType type){
        contextHolder.set(type);
    }
    
    public static DatabaseType getDatabaseType(){
        return contextHolder.get();
    }
}

作用：构建一个DatabaseType容器，并提供了向其中设置和获取DatabaseType的方法

4、DynamicDataSource

package com.zzg.myboot.datasource;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 动态数据源（需要继承AbstractRoutingDataSource）
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    protected Object determineCurrentLookupKey() {
        return DatabaseContextHolder.getDatabaseType();
    }
}

作用：使用DatabaseContextHolder获取当前线程的DatabaseType

5、MyBatisConfig

package com.zzg.myboot.common;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.zzg.myboot.datasource.DatabaseType;
import com.zzg.myboot.datasource.DynamicDataSource;


/**
 * springboot集成mybatis的基本入口 1）创建数据源(如果采用的是默认的tomcat-jdbc数据源，则不需要)
 * 2）创建SqlSessionFactory 3）配置事务管理器，除非需要使用事务，否则不用配置
 */
@Configuration // 该注解类似于spring配置文件
@MapperScan(basePackages = "com.zzg.myboot.mapper")
public class MyBatisConfig {

    @Autowired
    private Environment env;

    /**
     * 创建数据源(数据源的名称：方法名可以取为XXXDataSource(),XXX为数据库名称,该名称也就是数据源的名称)
     */
    @Bean
    public DataSource readDataSource() throws Exception {
        Properties props = new Properties();
        props.put("driverClassName", env.getProperty("jdbc.driverClassName"));
        props.put("url", env.getProperty("jdbc.url"));
        props.put("username", env.getProperty("jdbc.username"));
        props.put("password", env.getProperty("jdbc.password"));
        return DruidDataSourceFactory.createDataSource(props);
    }

    @Bean
    public DataSource writeDataSource() throws Exception {
        Properties props = new Properties();
        props.put("driverClassName", env.getProperty("jdbc2.driverClassName"));
        props.put("url", env.getProperty("jdbc2.url"));
        props.put("username", env.getProperty("jdbc2.username"));
        props.put("password", env.getProperty("jdbc2.password"));
        return DruidDataSourceFactory.createDataSource(props);
    }

    /**
     * @Primary 该注解表示在同一个接口有多个实现类可以注入的时候，默认选择哪一个，而不是让@autowire注解报错
     * @Qualifier 根据名称进行注入，通常是在具有相同的多个类型的实例的一个注入（例如有多个DataSource类型的实例）
     */
    @Bean
    @Primary
    public DynamicDataSource dataSource(@Qualifier("readDataSource") DataSource readDataSource,
            @Qualifier("writeDataSource") DataSource writeDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
        targetDataSources.put(DatabaseType.read, readDataSource);
        targetDataSources.put(DatabaseType.write, writeDataSource);

        DynamicDataSource dataSource = new DynamicDataSource();
        dataSource.setTargetDataSources(targetDataSources);// 该方法是AbstractRoutingDataSource的方法
        dataSource.setDefaultTargetDataSource(readDataSource);// 默认的datasource设置为myTestDbDataSource

        return dataSource;
    }

    /**
     * 根据数据源创建SqlSessionFactory
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory(DynamicDataSource ds) throws Exception {
        SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
        fb.setDataSource(ds);// 指定数据源(这个必须有，否则报错)
        // 下边两句仅仅用于*.xml文件，如果整个持久层操作不需要使用到xml文件的话（只用注解就可以搞定），则不加
        fb.setTypeAliasesPackage(env.getProperty("mybatis.typeAliasesPackage"));// 指定基包
        fb.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources(env.getProperty("mybatis.mapperLocations")));//

        return fb.getObject();
    }

    /**
     * 配置事务管理器
     */
    @Bean
    public DataSourceTransactionManager transactionManager(DynamicDataSource dataSource) throws Exception {
        return new DataSourceTransactionManager(dataSource);
    }

}

作用：

  • 通过读取application.properties文件生成两个数据源（readDataSource、writeDataSource）
  • 使用以上生成的两个数据源构造动态数据源dataSource
    • @Primary：指定在同一个接口有多个实现类可以注入的时候，默认选择哪一个，而不是让@Autowire注解报错（一般用于多数据源的情况下）
    • @Qualifier：指定名称的注入，当一个接口有多个实现类的时候使用（在本例中，有两个DataSource类型的实例，需要指定名称注入）
    • @Bean：生成的bean实例的名称是方法名（例如上边的@Qualifier注解中使用的名称是前边两个数据源的方法名，而这两个数据源也是使用@Bean注解进行注入的）
  • 通过动态数据源构造SqlSessionFactory和事务管理器（如果不需要事务，后者可以去掉）
6、使用
UserMapper.java 
package com.zzg.myboot.mapper;

import com.zzg.myboot.domain.User;

public interface UserMapper {
	int deleteByPrimaryKey(Long id);

	int insert(User record);

	int insertSelective(User record);

	User selectByPrimaryKey(Long id);

	int updateByPrimaryKeySelective(User record);

	int updateByPrimaryKey(User record);
}

UserDao.java 
package com.zzg.myboot.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.zzg.myboot.datasource.DatabaseContextHolder;
import com.zzg.myboot.datasource.DatabaseType;
import com.zzg.myboot.domain.User;
import com.zzg.myboot.mapper.UserMapper;

@Repository
public class UserDao {
	 @Autowired
	 private UserMapper mapper;
	 
	 public int deleteByPrimaryKey(Long id){
		 DatabaseContextHolder.setDatabaseType(DatabaseType.write);
		 return mapper.deleteByPrimaryKey(id);
	 }

	 public	int insert(User record){
		 DatabaseContextHolder.setDatabaseType(DatabaseType.write);
		 return mapper.insert(record);
	 }

	 public	int insertSelective(User record){
		 DatabaseContextHolder.setDatabaseType(DatabaseType.write);
		 return mapper.insertSelective(record);
	 }

	 public	User selectByPrimaryKey(Long id){
		 DatabaseContextHolder.setDatabaseType(DatabaseType.read);
		 return mapper.selectByPrimaryKey(id);
	 }

	 public int updateByPrimaryKeySelective(User record){
		 DatabaseContextHolder.setDatabaseType(DatabaseType.write);
		 return mapper.updateByPrimaryKeySelective(record);
	 }

	 public	int updateByPrimaryKey(User record){
		 DatabaseContextHolder.setDatabaseType(DatabaseType.write);
		 return mapper.updateByPrimaryKey(record);
	 }
	 

}

UserService.java 
package com.zzg.myboot.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.zzg.myboot.dao.UserDao;
import com.zzg.myboot.domain.User;

@Service
public class UserService {
	 @Autowired
	 private UserDao dao;
	 
	 public int deleteByPrimaryKey(Long id){
		 return dao.deleteByPrimaryKey(id);
	 }

	 public	int insert(User record){
		 return dao.insert(record);
	 }

	 public	int insertSelective(User record){
		 return dao.insertSelective(record);
	 }

	 public	User selectByPrimaryKey(Long id){
		 return dao.selectByPrimaryKey(id);
	 }

	 public int updateByPrimaryKeySelective(User record){
		 return dao.updateByPrimaryKeySelective(record);
	 }

	 public	int updateByPrimaryKey(User record){
		 return dao.updateByPrimaryKey(record);
	 }
	 

}

UserController.java 
package com.zzg.myboot.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.zzg.myboot.domain.User;
import com.zzg.myboot.service.UserService;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@RestController
@RequestMapping("/user")
@Api("UserController相关api")
public class UserController {
	
		@Autowired
	    private UserService service;
		
		@ApiOperation("获取user信息,测试多数据源")
	    @RequestMapping(value = "/getUser", method = RequestMethod.GET)
	    public User getShop(@RequestParam("id") String id) {
	        return service.selectByPrimaryKey(Long.parseLong(id));
	    }

}

user.sql 和UserMapper.xml 
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` bigint(19) NOT NULL auto_increment,
  `loginname` varchar(64) default NULL,
  `name` varchar(64) default NULL,
  `password` varchar(64) default NULL,
  `sex` tinyint(2) default '0',
  `age` tinyint(2) default '0',
  `usertype` tinyint(2) default '0',
  `status` tinyint(2) default '0',
  `organization_id` int(11) default '0',
  `createdate` datetime default NULL,
  `phone` varchar(20) default NULL,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户';

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.zzg.myboot.mapper.UserMapper" >
  <resultMap id="BaseResultMap" type="com.zzg.myboot.domain.User" >
    <id column="id" property="id" jdbcType="BIGINT" />
    <result column="loginname" property="loginname" jdbcType="VARCHAR" />
    <result column="name" property="name" jdbcType="VARCHAR" />
    <result column="password" property="password" jdbcType="VARCHAR" />
    <result column="sex" property="sex" jdbcType="TINYINT" />
    <result column="age" property="age" jdbcType="TINYINT" />
    <result column="usertype" property="usertype" jdbcType="TINYINT" />
    <result column="status" property="status" jdbcType="TINYINT" />
    <result column="organization_id" property="organizationId" jdbcType="INTEGER" />
    <result column="createdate" property="createdate" jdbcType="TIMESTAMP" />
    <result column="phone" property="phone" jdbcType="VARCHAR" />
  </resultMap>
  <sql id="Base_Column_List" >
    id, loginname, name, password, sex, age, usertype, status, organization_id, createdate, 
    phone
  </sql>
  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Long" >
    select 
    <include refid="Base_Column_List" />
    from user
    where id = #{id,jdbcType=BIGINT}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Long" >
    delete from user
    where id = #{id,jdbcType=BIGINT}
  </delete>
  <insert id="insert" parameterType="com.zzg.myboot.domain.User" >
    insert into user (id, loginname, name, 
      password, sex, age, 
      usertype, status, organization_id, 
      createdate, phone)
    values (#{id,jdbcType=BIGINT}, #{loginname,jdbcType=VARCHAR}, #{name,jdbcType=VARCHAR}, 
      #{password,jdbcType=VARCHAR}, #{sex,jdbcType=TINYINT}, #{age,jdbcType=TINYINT}, 
      #{usertype,jdbcType=TINYINT}, #{status,jdbcType=TINYINT}, #{organizationId,jdbcType=INTEGER}, 
      #{createdate,jdbcType=TIMESTAMP}, #{phone,jdbcType=VARCHAR})
  </insert>
  <insert id="insertSelective" parameterType="com.zzg.myboot.domain.User" >
    insert into user
    <trim prefix="(" suffix=")" suffixOverrides="," >
      <if test="id != null" >
        id,
      </if>
      <if test="loginname != null" >
        loginname,
      </if>
      <if test="name != null" >
        name,
      </if>
      <if test="password != null" >
        password,
      </if>
      <if test="sex != null" >
        sex,
      </if>
      <if test="age != null" >
        age,
      </if>
      <if test="usertype != null" >
        usertype,
      </if>
      <if test="status != null" >
        status,
      </if>
      <if test="organizationId != null" >
        organization_id,
      </if>
      <if test="createdate != null" >
        createdate,
      </if>
      <if test="phone != null" >
        phone,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides="," >
      <if test="id != null" >
        #{id,jdbcType=BIGINT},
      </if>
      <if test="loginname != null" >
        #{loginname,jdbcType=VARCHAR},
      </if>
      <if test="name != null" >
        #{name,jdbcType=VARCHAR},
      </if>
      <if test="password != null" >
        #{password,jdbcType=VARCHAR},
      </if>
      <if test="sex != null" >
        #{sex,jdbcType=TINYINT},
      </if>
      <if test="age != null" >
        #{age,jdbcType=TINYINT},
      </if>
      <if test="usertype != null" >
        #{usertype,jdbcType=TINYINT},
      </if>
      <if test="status != null" >
        #{status,jdbcType=TINYINT},
      </if>
      <if test="organizationId != null" >
        #{organizationId,jdbcType=INTEGER},
      </if>
      <if test="createdate != null" >
        #{createdate,jdbcType=TIMESTAMP},
      </if>
      <if test="phone != null" >
        #{phone,jdbcType=VARCHAR},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.zzg.myboot.domain.User" >
    update user
    <set >
      <if test="loginname != null" >
        loginname = #{loginname,jdbcType=VARCHAR},
      </if>
      <if test="name != null" >
        name = #{name,jdbcType=VARCHAR},
      </if>
      <if test="password != null" >
        password = #{password,jdbcType=VARCHAR},
      </if>
      <if test="sex != null" >
        sex = #{sex,jdbcType=TINYINT},
      </if>
      <if test="age != null" >
        age = #{age,jdbcType=TINYINT},
      </if>
      <if test="usertype != null" >
        usertype = #{usertype,jdbcType=TINYINT},
      </if>
      <if test="status != null" >
        status = #{status,jdbcType=TINYINT},
      </if>
      <if test="organizationId != null" >
        organization_id = #{organizationId,jdbcType=INTEGER},
      </if>
      <if test="createdate != null" >
        createdate = #{createdate,jdbcType=TIMESTAMP},
      </if>
      <if test="phone != null" >
        phone = #{phone,jdbcType=VARCHAR},
      </if>
    </set>
    where id = #{id,jdbcType=BIGINT}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.zzg.myboot.domain.User" >
    update user
    set loginname = #{loginname,jdbcType=VARCHAR},
      name = #{name,jdbcType=VARCHAR},
      password = #{password,jdbcType=VARCHAR},
      sex = #{sex,jdbcType=TINYINT},
      age = #{age,jdbcType=TINYINT},
      usertype = #{usertype,jdbcType=TINYINT},
      status = #{status,jdbcType=TINYINT},
      organization_id = #{organizationId,jdbcType=INTEGER},
      createdate = #{createdate,jdbcType=TIMESTAMP},
      phone = #{phone,jdbcType=VARCHAR}
    where id = #{id,jdbcType=BIGINT}
  </update>
</mapper>


模拟测试数据库切换
第一情况：用户存在master库 select 权限，截图如下：

第二种情况：用户存在master库update 权限，截图如下：



































在奋斗的大道
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用eclipse创建 MAVEN项目，SpringBoot+Mybatis完成基础项目搭建（一）
dong_learnning的博客
06-28 1493
1.创建Maven项目。 1.鼠标右键---->New----->Other… next… next… 2.这里： Group Id 中输入项目的基本包名。 Artifact Id 中输入项目名。 Version 中的值默认就行，不进行选择。 Package 中写的是默认生成的一个包名，不写也可以。 接着点击完成就可以了。 3.项目生成后的目录： 可以运行App.java,控制台...
eclipse中创建SpringBoot+mybatis
weixin_49651385的博客
07-26 1032
1.安装SpringBooT插件 （1）在打开help—>marketplace （2）安装完成sprongboot插件后重启eclipse。 2.新建工程 （1）打开file （2）在输入框中输入Spring找到SpringBoot （3）在输入框中输入项目名称 （4）选择框架 （5）点击filsh完成创建 3.创建完工程直接启动项目可能出现的异常： （1）Eclipse下“找不到或无法加载主类”的错误 （2）java.lang.UnsupportedClassVersionError: c
SpringBoot整合Mybatis（详解，一看就会）
最新发布
m0_67267524的博客
05-19 720
在resource创建好之后，我们在resource目录下创建application.yml，创建完之后写数据库配置文件，根据自己的 数据库和数据库账号和密码进行更改，改成自己的，以及端口，我这边端口是8081，根据自己可以修改端口，默认是 8080。注：本类中不要忘记写@service，以及依赖注入UserMapper，刚开始可以直接复制我的代码，后面自己去慢慢理解。至此我们的SpringBoot+Mybatis已经整合完毕了 我们运行项目，显示如下，我们已经运行完毕且没有错误。delete用于删除。
Eclipse中实现SpringBoot与Mybatis整合（图文教程带源码）
BADAO_LIUMANG_QIZHI的博客
03-18 3526
场景 数据库中数据 实现效果 项目结构 前面参照 Eclipse中新建SpringBoot项目并输出HelloWorld https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/88359953 Eclipse中新建SpringBoot项目完成对json、pojo、map、list的请求 https://blo...
Eclipse搭建springBoot进阶篇-SpringBoot+Mybatis
大道至简，悟在天成。
01-25 6148
Eclipse搭建springBoot入门篇 https://blog.csdn.net/qq_17025903/article/details/85675839 在入门篇了搭建了一个简单的SpringBoot的Demo，在进阶篇将真正引入实战，也就是能支撑基本的企业中小型项目开发。 本次通过springBoot+Mybatis+maven等搭建一个适用于开发中小型项目的简单架构 ...
Eclipse创建Spring Boot + MySql + mybatis项目
王延朕的博客
02-07 1595
1.创建SpringBoot项目 a.创建SpringBoot项目的方式有几种，最直接的方式是在https://start.spring.io页面中填写项目的必要参数，勾选所需要添加的依赖，点击Generate按钮，即可下载项目。 将下载得到的压缩包解压，并将解压得到的文件夹移动到Workspace中，然后，通过Eclipse的Import -> Exsiting Maven Project...
springboot+mybatis plus整合案例
12-14
在本文中，我们将深入探讨如何将SpringBoot与MyBatis Plus进行整合，以便构建一个高效、简洁的Web应用程序。SpringBoot以其快速启动和简化配置的特点，成为开发微服务的首选框架，而MyBatis Plus则作为MyBatis的增强...
springboot+mybatis 整合Demo下载
02-02
SpringBoot简化了Spring应用的初始搭建以及开发过程，而MyBatis则是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。现在我们来深入探讨如何将这两个框架整合，并通过这个名为"xyspringboot"的Demo来...
eclipse+maven+springmvc+spring+mybatis案例附带mysql数据库
04-24
它涵盖了多个关键的技术栈，包括Eclipse IDE、Maven构建工具、Spring MVC作为MVC框架、Spring核心框架以及MyBatis持久层框架，同时配合MySQL数据库进行数据存储。 【Eclipse】是广泛使用的Java开发集成环境，提供了...
创建springboot + mybatis项目，实现登录、注册功能详细过程
09-10
2. 创建`application.properties`，配置数据源、MyBatis的SqlSessionFactory和Mapper扫描路径。 **步骤三：建立数据库模型** 1. 设计用户表结构，如`users`表，包括`id`、`username`、`password`等字段。 2. 使用...
eclipse下SpringMVC+Maven+Mybatis+MySQL项目搭建
05-28
本项目"eclipse下SpringMVC+Maven+Mybatis+MySQL项目搭建"就是一个典型的Java Web开发实例，它利用了SpringMVC作为控制层，Maven作为项目构建工具，Mybatis作为数据持久层框架，以及MySQL作为数据库管理系统。...
eclipse搭建springboot+mybatis具体流程（参考）和demo
04-10
这俩天在学习springboot+mybatis框架，然后自己从自己的eclipse试了下，搞的挺烦的，就把demo和eclipse怎么创建springboot项目步骤分享给你们
SpringBoot+Mybatis整合完整源码
04-02
Spring Boot+Mybatis+Maven 整合项目，可供学习，教程地址https://blog.csdn.net/qq_33768099/article/details/79787215
Spring-boot+Mybatis+Maven+MySql搭建实例
02-08
最近读了spring-boot开发手册，spring-boot相比于spring-mvc封装了很多常用的依赖，并且内置了tomcat容器，启动生成的jar包即可启动项目，也是目前流行的微服务常用框架。本文主要用到了spring-boot，以及mybatis，数据库用到了mysql。
springboot+mybatis整合（最详细）从maven项目开始
热门推荐
huangwei18351的博客
12-24 3万+
1 新建maven项目 2 在pom.xml中加入spring boot 所需要的配置，创建spring boot的application.java执行文件 2.1 在pom.xml中引入spring-boot-start-parent，这是必须的 2.2需要在pom.xml中引入spring-boot-starter-web依赖，依赖放在<dependencies&g...
SpringBoot + Mybatis搭建完整的项目架构
07-02 832
准备工作： Java开发环境 已安装 springboot 插件（STS）的 Eclipse MySQL服务 一、 创建 springboot 项目 1. 打开Eclipse --> 左上角 File --> New --> Other ，到如下界面 如果没有 Spring Starter Project 这个选项，说明 Eclipse 的...
eclipse+maven+springboot+mybatis+jsp实现增删改查web项目的详细步骤
qq_37275342的博客
01-14 1874
1、搭建环境 （1）、搭建环境准备工作 a、官网下载eclipse b、官网下载maven，并配置maven环境，和本地仓库路径 c、eclipse配置maven （2）、新建项目 （1）file—》new—》maven project （2）点击next （3）next （4）finish完成 （5）哈哈到此环境就搭建完了 2、代码和框架构架 （1）、dao @Mapper publ...
eclipse下spring boot 整合 mybatis、mysql
hellorichen的专栏
07-03 325
eclipse下spring boot 整合 mybatis、mysql 参考：https://blog.csdn.net/wangjiankai1993/article/details/80272886 项目下载地址：https://download.csdn.net/download/hellorichen/11271593
eclipse+springboot +mybatis 部署声明
06-12
首先，你需要将Spring Boot项目打包成一个可执行的jar文件，可以使用Maven或Gradle等构建工具...如果你的应用程序需要使用MyBatis进行数据访问，你需要在你的应用程序中添加MyBatis依赖并配置MyBatis的数据源和映射器。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值