精华内容
下载资源
问答
  • SpringBoot整合Mybatis完整详细版

    万次阅读 多人点赞 2018-09-27 10:05:56
    于是写下本篇SpringBoot整合Mybatis的文章,做个笔记。 本章节主要搭建框架,下章节实现登录注册以及拦截器的配置: SpringBoot整合Mybatis完整详细版二:注册、登录、拦截器配置 本章项目源码下载: ...

    记得刚接触SpringBoot时,大吃一惊,世界上居然还有这么省事的框架,立马感叹:SpringBoot是世界上最好的框架。哈哈!

    当初跟着教程练习搭建了一个框架,传送门:spring boot + jpa + bootstrap + thymeleaf 简单的增删改查Demo

    后来进了新公司,用不到而且忙于任务,今天重温一遍居然有些忘了,看来真是好记性不如烂笔头。于是写下本篇SpringBoot整合Mybatis的文章,做个笔记。

    本章节主要搭建框架,下章节实现登录注册以及拦截器的配置:SpringBoot整合Mybatis完整详细版二:注册、登录、拦截器配置

    本章项目源码下载:springBoot整合mybatis完整详细版

    github地址:https://github.com/wjup/springBoot_Mybatis

    练习完此篇,可下载一小时快速撸出一个短网址生成项目源码来看(欢迎star),也是非常适合入门练手的。

    天也不早了,言归正传,开始


    IDE:idea、DB:mysql

    • 新建一个Spring Initializr项目

    • 创建项目的文件结构以及jdk的版本 

    • 选择项目所需要的依赖

    • 修改项目名,finish完成

    • 来看下建好后的pom
    <?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.example</groupId>
    	<artifactId>demo</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
    
    	<name>demo</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-jdbc</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</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>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    
    </project>
    
    • 修改配置文件

    本文不使用application.properties文件 而使用更加简洁的application.yml文件。将resource文件夹下原有的application.properties文件删除,创建application.yml配置文件(备注:其实SpringBoot底层会把application.yml文件解析为application.properties),本文创建了两个yml文件(application.yml和application-dev.yml),分别来看一下内容

    application.yml

    spring:
      profiles:
        active: dev

    application-dev.yml

    server:
      port: 8080
    
    spring:
      datasource:
        username: root
        password: 1234
        url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
        driver-class-name: com.mysql.jdbc.Driver
    
    mybatis:
      mapper-locations: classpath:mapping/*Mapper.xml
      type-aliases-package: com.example.entity
    
    #showSql
    logging:
      level:
        com:
          example:
            mapper : debug

    两个文件的意思是:

    在项目中配置多套环境的配置方法。
    因为现在一个项目有好多环境,开发环境,测试环境,准生产环境,生产环境,每个环境的参数不同,所以我们就可以把每个环境的参数配置到yml文件中,这样在想用哪个环境的时候只需要在主配置文件中将用的配置文件写上就行如application.yml

    笔记:在Spring Boot中多环境配置文件名需要满足application-{profile}.yml的格式,其中{profile}对应你的环境标识,比如:

    application-dev.yml:开发环境
    application-test.yml:测试环境
    application-prod.yml:生产环境
    至于哪个具体的配置文件会被加载,需要在application.yml文件中通过spring.profiles.active属性来设置,其值对应{profile}值。

    还有配置文件中最好不要有中文注释,会报错。

    解决方法(未测试):spring boot application.yml文件中文注释乱码

    接下来把启动文件移到com.example下,而且springboot的启动类不能放在java目录下!!!必须要个包将它包进去

    否则会报错误:

    Your ApplicationContext is unlikely to start due to a @ComponentScan of the default package.

    这个原因值得注意就是因为有时候很难在IDEA中的项目目录认出来这个错误并且还容易扫描不到一些类,传送门:SpringBoot扫描不到controller

                             

    • 然后开始创建实体类实现业务流程

    创建包controller、entity、mapper、service。resources下创建mapping文件夹,用于写sql语句,也可以用注解的方式直接写在mapper文件里。下面直接贴代码

    数据库表结构(之前小项目的表,直接拿来用)

    CREATE TABLE `user` (
      `id` int(32) NOT NULL AUTO_INCREMENT,
      `userName` varchar(32) NOT NULL,
      `passWord` varchar(50) NOT NULL,
      `realName` varchar(32) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

    entity.java

    package com.example.entity;
    
    /**
     * @Author:wjup
     * @Date: 2018/9/26 0026
     * @Time: 14:39
     */
    public class User {
        private Integer id;
        private String userName;
        private String passWord;
        private String realName;
    
        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 String getRealName() {
            return realName;
        }
    
        public void setRealName(String realName) {
            this.realName = realName;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", userName='" + userName + '\'' +
                    ", passWord='" + passWord + '\'' +
                    ", realName='" + realName + '\'' +
                    '}';
        }
    }
    

    UserController.java

    package com.example.controller;
    
    import com.example.entity.User;
    import com.example.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @Author:wjup
     * @Date: 2018/9/26 0026
     * @Time: 14:42
     */
    
    @RestController
    @RequestMapping("/testBoot")
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        @RequestMapping("getUser/{id}")
        public String GetUser(@PathVariable int id){
            return userService.Sel(id).toString();
        }
    }
    

    UserService.java

    package com.example.service;
    
    import com.example.entity.User;
    import com.example.mapper.UserMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    /**
     * @Author:wjup
     * @Date: 2018/9/26 0026
     * @Time: 15:23
     */
    @Service
    public class UserService {
        @Autowired
        UserMapper userMapper;
        public User Sel(int id){
            return userMapper.Sel(id);
        }
    }
    

    UserMapper.java

    package com.example.mapper;
    
    import com.example.entity.User;
    import org.apache.ibatis.annotations.Select;
    import org.springframework.stereotype.Repository;
    
    /**
     * @Author:wjup
     * @Date: 2018/9/26 0026
     * @Time: 15:20
     */
    @Repository
    public interface UserMapper {
    
        User Sel(int id);
    }
    

    UserMapping.xml

    <?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.example.mapper.UserMapper">
    
        <resultMap id="BaseResultMap" type="com.example.entity.User">
            <result column="id" jdbcType="INTEGER" property="id" />
            <result column="userName" jdbcType="VARCHAR" property="userName" />
            <result column="passWord" jdbcType="VARCHAR" property="passWord" />
            <result column="realName" jdbcType="VARCHAR" property="realName" />
        </resultMap>
    
        <select id="Sel" resultType="com.example.entity.User">
            select * from user where id = #{id}
        </select>
    
    </mapper>
    
    • 最终框架结构

    • 完成以上,下面在启动类里加上注解用于给出需要扫描的mapper文件路径@MapperScan("com.example.mapper") 
    package com.example;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @MapperScan("com.example.mapper") //扫描的mapper
    @SpringBootApplication
    public class DemoApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(DemoApplication.class, args);
    	}
    }
    

    测试成功,就这样基本框架就搭建成功了

    • 最后给个番外篇如何更改启动时显示的字符拼成的字母,就是更改下图标红框的地方

    其实很好改,只需要在resources下新建一个txt文件就可以,命名为banner.txt,那这种字符该怎么拼出来呢,下面推荐一个网址,有这种工具,链接传送门:字母转字符。如下:

    直接输入要生成的字母,系统会自动转换,然后复制下面转换好的字符到新建的banner.txt文件中,重新启动项目就可以了。


    ---路漫漫其修远兮,吾将上下而求索

     

     

    展开全文
  • server.port=8989 spring.datasource.url=jdbc:mysql://localhost:3306/spring?useSSL=false spring.datasource.driver-class-name=...spring.datasource.username=root spring.datasource.password=123456
  • 最简单的SpringBoot整合MyBatis教程

    万次阅读 多人点赞 2019-03-18 17:22:16
    前面两篇文章和读者聊了Spring Boot中最简单的数据持久化方案JdbcTemplate,JdbcTemplate虽然简单,但是用的并不多,因为它没有MyBatis方便,在Spring+SpringMVC中整合MyBatis步骤还是有点复杂的,要配置多个Bean,...

    前面两篇文章和读者聊了Spring Boot中最简单的数据持久化方案JdbcTemplate,JdbcTemplate虽然简单,但是用的并不多,因为它没有MyBatis方便,在Spring+SpringMVC中整合MyBatis步骤还是有点复杂的,要配置多个Bean,Spring Boot中对此做了进一步的简化,使MyBatis基本上可以做到开箱即用,本文就来看看在Spring Boot中MyBatis要如何使用。

    工程创建

    首先创建一个基本的Spring Boot工程,添加Web依赖,MyBatis依赖以及MySQL驱动依赖,如下:

    在这里插入图片描述

    创建成功后,添加Druid依赖,并且锁定MySQL驱动版本,完整的依赖如下:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.0.0</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.28</version>
        <scope>runtime</scope>
    </dependency>
    

    如此,工程就算是创建成功了。读者注意,MyBatis和Druid依赖的命名和其他库的命名不太一样,是属于xxx-spring-boot-stater模式的,这表示该starter是由第三方提供的。

    基本用法

    MyBatis的使用和JdbcTemplate基本一致,首先也是在application.properties中配置数据库的基本信息:

    spring.datasource.url=jdbc:mysql:///test01?useUnicode=true&characterEncoding=utf-8
    spring.datasource.username=root
    spring.datasource.password=root
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    

    配置完成后,MyBatis就可以创建Mapper来使用了,例如我这里直接创建一个UserMapper2,如下:

    public interface UserMapper2 {
        @Select("select * from user")
        List<User> getAllUsers();
    
        @Results({
                @Result(property = "id", column = "id"),
                @Result(property = "username", column = "u"),
                @Result(property = "address", column = "a")
        })
        @Select("select username as u,address as a,id as id from user where id=#{id}")
        User getUserById(Long id);
    
        @Select("select * from user where username like concat('%',#{name},'%')")
        List<User> getUsersByName(String name);
    
        @Insert({"insert into user(username,address) values(#{username},#{address})"})
        @SelectKey(statement = "select last_insert_id()", keyProperty = "id", before = false, resultType = Integer.class)
        Integer addUser(User user);
    
        @Update("update user set username=#{username},address=#{address} where id=#{id}")
        Integer updateUserById(User user);
    
        @Delete("delete from user where id=#{id}")
        Integer deleteUserById(Integer id);
    }
    

    这里是通过全注解的方式来写SQL,不写XML文件,@Select、@Insert、@Update以及@Delete四个注解分别对应XML中的select、insert、update以及delete标签,@Results注解类似于XML中的ResultMap映射文件(getUserById方法给查询结果的字段取别名主要是向小伙伴们演示下@Results注解的用法),另外使用@SelectKey注解可以实现主键回填的功能,即当数据插入成功后,插入成功的数据id会赋值到user对象的id属性上。

    UserMapper2创建好之后,还要配置mapper扫描,有两种方式,一种是直接在UserMapper2上面添加@Mapper注解,这种方式有一个弊端就是所有的Mapper都要手动添加,要是落下一个就会报错,还有一个一劳永逸的办法就是直接在启动类上添加Mapper扫描,如下:

    @SpringBootApplication
    @MapperScan(basePackages = "org.sang.mybatis.mapper")
    public class MybatisApplication {
        public static void main(String[] args) {
            SpringApplication.run(MybatisApplication.class, args);
        }
    }
    

    好了,做完这些工作就可以去测试Mapper的使用了。

    mapper映射

    当然,开发者也可以在XML中写SQL,例如创建一个UserMapper,如下:

    public interface UserMapper {
        List<User> getAllUser();
    
        Integer addUser(User user);
    
        Integer updateUserById(User user);
    
        Integer deleteUserById(Integer id);
    }
    

    然后创建UserMapper.xml文件,如下:

    <?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="org.sang.mybatis.mapper.UserMapper">
        <select id="getAllUser" resultType="org.sang.mybatis.model.User">
            select * from t_user;
        </select>
        <insert id="addUser" parameterType="org.sang.mybatis.model.User">
            insert into user (username,address) values (#{username},#{address});
        </insert>
        <update id="updateUserById" parameterType="org.sang.mybatis.model.User">
            update user set username=#{username},address=#{address} where id=#{id}
        </update>
        <delete id="deleteUserById">
            delete from user where id=#{id}
        </delete>
    </mapper>
    

    将接口中方法对应的SQL直接写在XML文件中。

    那么这个UserMapper.xml到底放在哪里呢?有两个位置可以放,第一个是直接放在UserMapper所在的包下面:

    在这里插入图片描述

    放在这里的UserMapper.xml会被自动扫描到,但是有另外一个Maven带来的问题,就是java目录下的xml资源在项目打包时会被忽略掉,所以,如果UserMapper.xml放在包下,需要在pom.xml文件中再添加如下配置,避免打包时java目录下的XML文件被自动忽略掉:

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
    </build>
    

    当然,UserMapper.xml也可以直接放在resources目录下,这样就不用担心打包时被忽略了,但是放在resources目录下,又不能自动被扫描到,需要添加额外配置。例如我在resources目录下创建mapper目录用来放mapper文件,如下:

    在这里插入图片描述

    此时在application.properties中告诉mybatis去哪里扫描mapper:

    mybatis.mapper-locations=classpath:mapper/*.xml
    

    如此配置之后,mapper就可以正常使用了。注意第二种方式不需要在pom.xml文件中配置文件过滤。

    原理分析

    在SSM整合中,开发者需要自己提供两个Bean,一个SqlSessionFactoryBean,还有一个是MapperScannerConfigurer,在Spring Boot中,这两个东西虽然不用开发者自己提供了,但是并不意味着这两个Bean不需要了,在org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration类中,我们可以看到Spring Boot提供了这两个Bean,部分源码如下:

    @org.springframework.context.annotation.Configuration
    @ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
    @ConditionalOnSingleCandidate(DataSource.class)
    @EnableConfigurationProperties(MybatisProperties.class)
    @AutoConfigureAfter(DataSourceAutoConfiguration.class)
    public class MybatisAutoConfiguration implements InitializingBean {
    
      @Bean
      @ConditionalOnMissingBean
      public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        return factory.getObject();
      }
      @Bean
      @ConditionalOnMissingBean
      public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        ExecutorType executorType = this.properties.getExecutorType();
        if (executorType != null) {
          return new SqlSessionTemplate(sqlSessionFactory, executorType);
        } else {
          return new SqlSessionTemplate(sqlSessionFactory);
        }
      }
      @org.springframework.context.annotation.Configuration
      @Import({ AutoConfiguredMapperScannerRegistrar.class })
      @ConditionalOnMissingBean(MapperFactoryBean.class)
      public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {
    
        @Override
        public void afterPropertiesSet() {
          logger.debug("No {} found.", MapperFactoryBean.class.getName());
        }
      }
    }
    

    从类上的注解可以看出,当当前类路径下存在SqlSessionFactory、 SqlSessionFactoryBean以及DataSource时,这里的配置才会生效,SqlSessionFactory和SqlTemplate都被提供了。为什么要看这段代码呢?下篇文章,松哥和大伙分享Spring Boot中MyBatis多数据源的配置时,这里将是一个重要的参考。

    好了,本文就先说到这里,

    关注公众号【江南一点雨】,专注于 Spring Boot+微服务,定期视频教程分享,关注后回复 Java ,领取松哥为你精心准备的 Java 干货!

    展开全文
  • Spring MVC整合Mybatis

    千次下载 热门讨论 2012-08-17 11:40:16
    Spring MVC整合Mybatis示例,该文本与http://blog.csdn.net/geloin/article/details/7536968配套。
  • 利用IDEA搭建SpringBoot项目,整合mybatis,实现简单的登录功能。 利用闲余时间想自己搭建一个springboot+mybatis的项目,提升一下自己对项目的了解,毕竟自己还是一个小白,在这里为自己创建项目的过程做一个记录...

    利用IDEA搭建SpringBoot项目,整合mybatis,实现简单的登录功能。


    仅供参考!!!

    仅供参考!!!

    仅供参考!!!


            利用闲余时间想自己搭建一个springboot+mybatis的项目,提升一下自己对项目的了解,毕竟自己还是一个小白,在这里为自己创建项目的过程做一个记录,以便以后回忆。同时将搭建中遇到的问题也在这里做记录。如有遇到同样问题的同学,希望能给你一下借鉴。

           springboot的优势之一就是快速搭建项目,省去了自己导入jar包和配置xml的时间,使用非常方便。


    一,搭建项目:

    1、打开IDEA,点击File→New→Project...,如图1所示

                                                                图1  搭建项目


    2、当我们选择project...后,会看见如图2所示的页面,选择Spring Initializr,点击NEXT即可。

                                                                                               图2 搭建项目


    3、接下来将看到如图3所示的页面,在这个页面中我只是修改了名称。然后点击NEXT进行下一步。

                                                                                             图3 搭建项目

    4、当我点击NEXT时,却出现如图4所示的错误,这由于创建时因为Artifact的命名为大小写混合,将大写改为小写即可正常创建。

                                                                                 图4 搭建项目 (注意名称大小写问题)

    5、接下来我们修改上面的错误,我将springbootTest1→springboottest1,然后进行下一步。会看见如图5所示的页面。 在当前页面中我们一次选择左侧的Web、Template Engines、SQL。然后在中间部分选择我们需要的选项,最终选择结果如最右侧所示。然后点击NEXT,进行下一步。

                                                                              图5 搭建项目(选择需要的内容)

    6、如图6所示,进人创建项目的最后一个页面,在这里我们可以修改项目保存的位置。确认自己输入的内容,点击Fiish即可完成项目的创建。

                                                                 图6 搭建项目(可以修改文件路径)

    7、点击Finish后,出现如图7所示页面,我们选择New Window即可,即在新的IDEA中打开我们新建的项目。

                                                                            图7 打开项目


    二、启动项目、添加配置文件等

    1、打开新项目后,我们可以观察一下左侧的项目结构。如图8所示。

    生成的项目中,resources文件夹下,static文件夹下存放静态文件,比如css、js、html和图片等 。

    templates下存放html文件,controller默认访问该文件夹下的html文件。

    这个在application.properties配置文件中是可以修改的。 

    下面为项目生成的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.example</groupId>
    	<artifactId>springboottest1</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
    
    	<name>springboottest1</name>
    	<description>Demo project for Spring Boot</description>
    
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.0.4.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-jdbc</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-thymeleaf</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</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>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    
    </project>
    

                                                                                          图8 项目文件结构


    2、了解项目的文件结构后,我们尝试着启动项目。我们发现项目启动过程中出现错误,错误信息如图9所示。

                                                                                             图9 项目启动报错

          这是因为我们创建Spring Boot项目时,在选择组件时添加了mysql、mybatis,但现在还没有配置数据库,导致项目启动报错。

          我们需要在项目的application.properties文件中配置数据信息。如图10所示,是我自己配置的数据库,具体情况根据自己数据库的设置配置。

                                                                                图10 数据库配置

           数据库采用MySQL数据库,下面是数据库的设计,只有几个简单的字段。如图11所示。

                                                                                图11 数据库设计

         这里也可以不使用application.properties文件,采用更加简洁的application.yml文件。将resource文件夹下原有的application.properties文件删除,创建application.yml配置文件(备注:其实SpringBoot底层会把application.yml文件解析为application.properties), 文件的内容如下(此处只配置最基本的):

    server:
      port: 8080
    
    spring:
        datasource:
            name: test
            url: jdbc:mysql://127.0.0.1:3306/test
            username: root
            password: 123456
            driver-class-name: com.mysql.jdbc.Driver

     

           接下来再次尝试重新启动项目。发现项目可以正常启动了。可以打开浏览器访问http://localhost:8080/,访问结果如图12所示。证明项目正常启动了。

                                                                                            图12 访问结果


    三、项目整合mybatis

    1、application.yml文件中添加mybatis。

    
    server:
      port: 8080
    
    spring:
        datasource:
            name: test
            url: jdbc:mysql://127.0.0.1:3306/test
            username: root
            password: 123456
            driver-class-name: com.mysql.jdbc.Driver
    
    mybatis:
      mapper-locations: classpath:mapper/*.xml  #注意:一定要对应mapper映射xml文件的所在路径
      type-aliases-package: com.example.springboottest1.entity  # 注意:对应实体类的路径

    2、pom.xml中添加 mybatis generator 自动生成代码插件。

    <build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    			<!-- mybatis generator 自动生成代码插件 -->
    			<plugin>
    				<groupId>org.mybatis.generator</groupId>
    				<artifactId>mybatis-generator-maven-plugin</artifactId>
    				<version>1.3.1</version>
    				<configuration>
    					<configurationFile>${basedir}/src/main/resources/generator/generatorConfig.xml</configurationFile>
    					<overwrite>true</overwrite>
    					<verbose>true</verbose>
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>

    3、resource文件夹下创建generator文件夹,并在文件夹中创建generatorConfig.xml文件。文件内容如下所示:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE generatorConfiguration
            PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
            "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
    <generatorConfiguration>
        <!-- 数据库驱动:选择你的本地硬盘上面的数据库驱动包-->
        <classPathEntry  location="C:\Program Files (x86)\MySQL\Connector.J 5.1\mysql-connector-java-5.1.36-bin.jar"/>
        <context id="DB2Tables"  targetRuntime="MyBatis3">
            <commentGenerator>
                <property name="suppressDate" value="true"/>
                <!-- 是否去除自动生成的注释 true:是 : false:否 -->
                <property name="suppressAllComments" value="false"/>
            </commentGenerator>
            <!--数据库连接驱动类,URL,用户名、密码 -->
            <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://127.0.0.1/test" userId="root" password="123456">
            </jdbcConnection>
            <javaTypeResolver>
                <property name="forceBigDecimals" value="false"/>
            </javaTypeResolver>
            <!-- 生成(实体)模型的包名和位置-->
            <javaModelGenerator targetPackage="com.example.springboottest1.entity" targetProject="src">
                <property name="enableSubPackages" value="true"/>
                <property name="trimStrings" value="true"/>
            </javaModelGenerator>
            <!-- 生成XML映射文件的包名和位置-->
            <sqlMapGenerator targetPackage="resources.mapper" targetProject="src">
                <property name="enableSubPackages" value="true"/>
            </sqlMapGenerator>
            <!-- 生成DAO接口的包名和位置-->
            <javaClientGenerator type="XMLMAPPER" targetPackage="com.example.springboottest1.mapper" targetProject="src">
                <property name="enableSubPackages" value="true"/>
            </javaClientGenerator>
            <!-- 要生成的表 tableName是数据库中的表名或视图名 domainObjectName是实体类名-->
            <table tableName="user" domainObjectName="user" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"></table>
        </context>
    </generatorConfiguration>
    

    4、所有文件创建完成后,还需要进行简单的配置。Run→Edit Configurations...,然后选择maven,配置Command line。

    5、所用文件创建完成,并配置好相关设置,重新启动项目,启动后运行generator。通过控制台可以看见代码是否生成成功,或失败的原因。如果代码生成成功,可以在项目文件夹中看见生成的项目。

            这个过程共生成三个文件,一个实体类,dao,还有sql语句。

    5.1、生成的实体类entity:

    package com.example.springboottest1.entity;
    
    public class user {
        /**
         * This field was generated by MyBatis Generator.
         * This field corresponds to the database column user.id
         *
         * @mbggenerated
         */
        private Integer id;
    
        /**
         * This field was generated by MyBatis Generator.
         * This field corresponds to the database column user.username
         *
         * @mbggenerated
         */
        private String username;
    
        /**
         * This field was generated by MyBatis Generator.
         * This field corresponds to the database column user.password
         *
         * @mbggenerated
         */
        private String password;
    
        /**
         * This field was generated by MyBatis Generator.
         * This field corresponds to the database column user.age
         *
         * @mbggenerated
         */
        private Integer age;
    
        /**
         * This method was generated by MyBatis Generator.
         * This method returns the value of the database column user.id
         *
         * @return the value of user.id
         *
         * @mbggenerated
         */
        public Integer getId() {
            return id;
        }
    
        /**
         * This method was generated by MyBatis Generator.
         * This method sets the value of the database column user.id
         *
         * @param id the value for user.id
         *
         * @mbggenerated
         */
        public void setId(Integer id) {
            this.id = id;
        }
    
        /**
         * This method was generated by MyBatis Generator.
         * This method returns the value of the database column user.username
         *
         * @return the value of user.username
         *
         * @mbggenerated
         */
        public String getUsername() {
            return username;
        }
    
        /**
         * This method was generated by MyBatis Generator.
         * This method sets the value of the database column user.username
         *
         * @param username the value for user.username
         *
         * @mbggenerated
         */
        public void setUsername(String username) {
            this.username = username == null ? null : username.trim();
        }
    
        /**
         * This method was generated by MyBatis Generator.
         * This method returns the value of the database column user.password
         *
         * @return the value of user.password
         *
         * @mbggenerated
         */
        public String getPassword() {
            return password;
        }
    
        /**
         * This method was generated by MyBatis Generator.
         * This method sets the value of the database column user.password
         *
         * @param password the value for user.password
         *
         * @mbggenerated
         */
        public void setPassword(String password) {
            this.password = password == null ? null : password.trim();
        }
    
        /**
         * This method was generated by MyBatis Generator.
         * This method returns the value of the database column user.age
         *
         * @return the value of user.age
         *
         * @mbggenerated
         */
        public Integer getAge() {
            return age;
        }
    
        /**
         * This method was generated by MyBatis Generator.
         * This method sets the value of the database column user.age
         *
         * @param age the value for user.age
         *
         * @mbggenerated
         */
        public void setAge(Integer age) {
            this.age = age;
        }
    }

    5.2、生成的Dao:

    package com.example.springboottest1.mapper;
    
    import com.example.springboottest1.entity.user;
    
    public interface userMapper {
        /**
         * This method was generated by MyBatis Generator.
         * This method corresponds to the database table user
         *
         * @mbggenerated
         */
        int deleteByPrimaryKey(Integer id);
    
        /**
         * This method was generated by MyBatis Generator.
         * This method corresponds to the database table user
         *
         * @mbggenerated
         */
        int insert(user record);
    
        /**
         * This method was generated by MyBatis Generator.
         * This method corresponds to the database table user
         *
         * @mbggenerated
         */
        int insertSelective(user record);
    
        /**
         * This method was generated by MyBatis Generator.
         * This method corresponds to the database table user
         *
         * @mbggenerated
         */
        user selectByPrimaryKey(Integer id);
    
        /**
         * This method was generated by MyBatis Generator.
         * This method corresponds to the database table user
         *
         * @mbggenerated
         */
        int updateByPrimaryKeySelective(user record);
    
        /**
         * This method was generated by MyBatis Generator.
         * This method corresponds to the database table user
         *
         * @mbggenerated
         */
        int updateByPrimaryKey(user record);
    }

    5.3、生成的SQL语句(其中一些没有用的注释被我删掉了):

    <?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.example.springboottest1.mapper.userMapper" >
      <resultMap id="BaseResultMap" type="com.example.springboottest1.entity.user" >
        <!--
          WARNING - @mbggenerated
          This element is automatically generated by MyBatis Generator, do not modify.
        -->
        <id column="id" property="id" jdbcType="INTEGER" />
        <result column="username" property="username" jdbcType="VARCHAR" />
        <result column="password" property="password" jdbcType="VARCHAR" />
        <result column="age" property="age" jdbcType="INTEGER" />
      </resultMap>
      <sql id="Base_Column_List" >
          id,
          username,
          password,
          age
      </sql>
      <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
          select
          <include refid="Base_Column_List" />
          from user
          where id = #{id,jdbcType=INTEGER}
      </select>
      <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" >
          delete from user
          where id = #{id,jdbcType=INTEGER}
      </delete>
      <insert id="insert" parameterType="com.example.springboottest1.entity.user" >
          insert into user (id, username, password, age)
          values (
            #{id,jdbcType=INTEGER},
            #{username,jdbcType=VARCHAR},
            #{password,jdbcType=VARCHAR},
            #{age,jdbcType=INTEGER})
      </insert>
      <insert id="insertSelective" parameterType="com.example.springboottest1.entity.user" >
          insert into user
          <trim prefix="(" suffix=")" suffixOverrides="," >
            <if test="id != null" >
              id,
            </if>
            <if test="username != null" >
              username,
            </if>
            <if test="password != null" >
              password,
            </if>
            <if test="age != null" >
              age,
            </if>
          </trim>
          <trim prefix="values (" suffix=")" suffixOverrides="," >
            <if test="id != null" >
              #{id,jdbcType=INTEGER},
            </if>
            <if test="username != null" >
              #{username,jdbcType=VARCHAR},
            </if>
            <if test="password != null" >
              #{password,jdbcType=VARCHAR},
            </if>
            <if test="age != null" >
              #{age,jdbcType=INTEGER},
            </if>
          </trim>
      </insert>
      <update id="updateByPrimaryKeySelective" parameterType="com.example.springboottest1.entity.user" >
          update user
          <set >
            <if test="username != null" >
              username = #{username,jdbcType=VARCHAR},
            </if>
            <if test="password != null" >
              password = #{password,jdbcType=VARCHAR},
            </if>
            <if test="age != null" >
              age = #{age,jdbcType=INTEGER},
            </if>
          </set>
          where id = #{id,jdbcType=INTEGER}
      </update>
      <update id="updateByPrimaryKey" parameterType="com.example.springboottest1.entity.user" >
          update user
          set username = #{username,jdbcType=VARCHAR},
            password = #{password,jdbcType=VARCHAR},
            age = #{age,jdbcType=INTEGER}
          where id = #{id,jdbcType=INTEGER}
      </update>
    </mapper>

    四、测试访问

    做好以上的准备以后,可以简单的写一个小页面,试着访问一下。

    同时这个时候可以自己了解一下@Controller@RestController的区别,以及@ResponseBody的用法。

    1、比如写一个简单的HTML页面,HelloWord.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>HelloWord</title>
    </head>
    <body>
    <h1>hello springboot!!!</h1>
    </body>
    </html>

    2、访问页面的controller。helloController.java

    package com.example.springboottest1.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    @Controller
    @RequestMapping(value = {"/hello"})
    public class helloController {
    
        @RequestMapping(value = {"/springboot"})
        public String hello(){
            return "HelloWord";
        }
    }
    

    3、重新启动项目,访问http://localhost:8080/hello/springboot,访问的结果如下所示。

    五、编写用户登录过程代码

    1、编写简单的登录页面与注册页面

    (1)登录页面  userLogin.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>用户登录</title>
    </head>
    <body>
    请输入用户名与密码登录
    <form action="/user/userLogin" method="post">
        用户名:<input type="text" name="username" /><br>
        密&nbsp;&nbsp;&nbsp;码:<input type="password" name="password" /><br>
        <input type="submit" value="登录" />
        <a href="/user/registerpage" target="_blank">注册</a>
    </form>
    </body>
    </html>

    页面效果:

    (2)注册页面   register.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>注册</title>
    </head>
    <body>
    <form action="/user/uregister" method="post">
        用户名:<input type="text" name="username" /></br>
        密码:<input type="password" name="password" /></br>
        确认密码:<input type="password" name="password2" /></br>
        年龄:<input type="text" name="age" /></br>
        <input type="submit" value="注册">
    </form>
    </body>
    </html>

    页面效果:

    (3)登录成功页面  index.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>登录成功</title>
    </head>
    <body>
    <h1>用户名与密码正确,登录成功!!!</h1>
    
    </body>
    </html>

    页面效果:

    (4)登录失败页面  loginError.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>登录失败</title>
    </head>
    <body>
    <h1>用户名或密码错误,登录失败!!!</h1>
    </body>
    </html>

    页面效果:

    2、对于写代码的顺序,我是从xml(sql语句)开始写,然后Dao,Service,最后写Controller。下面为我的部分代码。(开始生成的代码没有用到的部分被我删除掉了)

    (1)xml(sql语句) userMapper.xml

    <?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.example.springboottest1.mapper.userMapper" >
     
        <!--用户登录验证-->
        <select id="userlogin" parameterType="user" resultType="User">
            SELECT id,username,password,age FROM user WHERE username = #{username} AND password = #{password}
        </select>
    
        <!--新用户注册  方式1-->
        <insert id="adduser" parameterType="user" useGeneratedKeys="true" keyProperty="id">
            INSERT INTO user (username,password,age) VALUES (#{username},#{password},#{age})
        </insert>
    
        <!--新用户注册  方式2-->
        <insert id="adduser1" parameterType="user">
            INSERT INTO user (id,username,password,age) VALUES (UUID(),#{username},#{password},#{age})
        </insert>
    
    </mapper>

    (2)Dao层 userMapper.java

    package com.example.springboottest1.mapper;
    
    import com.example.springboottest1.entity.User;
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    import org.springframework.stereotype.Component;
    
    import java.util.Map;
    
    @Mapper
    @Component
    public interface userMapper {
    
        //用户登录
        User userlogin(@Param("username") String username,@Param("password") String password);
    
        //注册新用户(方式1)
        int adduser(@Param("username") String username, @Param("password") String password, @Param("age") int age);
    
        //注册新用户(方式2)
        int adduser1(@Param("username") String username, @Param("password") String password, @Param("age") int age);
    }

    (3)Servicr层  UserLoginService.java

    package com.example.springboottest1.service;
    
    import com.example.springboottest1.entity.User;
    import com.example.springboottest1.mapper.userMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.Map;
    
    @Service
    public class UserLoginService {
    
        /**
         * 注入dao
         */
        @Autowired
        private userMapper usermapper;
    
        //用户登录
        public User userLogin(String username,String password){
            User user = usermapper.userlogin(username,password);
            return user;
        }
    
        //注册新用户
        public int adduser(String username,String password,int age){
    
    
            return usermapper.adduser(username,password,age);
            //return usermapper.adduser1(username,password,age);     //对应sql语句中的第二种注册方式
        }
    }
    

    (4)Controller层  UserLoginController.java

    package com.example.springboottest1.controller;
    
    import com.example.springboottest1.entity.User;
    import com.example.springboottest1.service.UserLoginService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import javax.servlet.http.HttpServletRequest;
    
    @Controller
    @RequestMapping(value = {"/user"})
    public class UserLoginController {
    
        /**
         * 注入service
         */
        @Autowired
        private UserLoginService userLoginService;
    
        /**
         * 跳转到用户登录页面
         * @return 登录页面
         */
        @RequestMapping(value = {"/loginHtml"})
        public String loginHtml(){
            return "userLogin";
        }
    
        /**
         * 跳转到用户注册页面
         * @return 注册页面
         */
        @RequestMapping(value = {"/registerpage"})
        public String registerpage(){
            return "register";
        }
    
        /**
         * 获取用户名与密码,用户登录
         * @return 登录成功页面
         */
        @RequestMapping(value = {"/userLogin"})
        public String userLogin(@RequestParam("username") String username, @RequestParam("password") String password, HttpServletRequest request){
    
            User user = userLoginService.userLogin(username,password);
    
            if(user != null){                                                  //登录成功
                request.getSession().setAttribute("session_user",user);     //将用户信息放入session
                return "index";
            }
            return "loginError";
        }
    
        /**
         * 注册新用户
         * @return 注册结果
         */
        @ResponseBody
        @RequestMapping(value = {"/uregister"})
        public String addUser(@RequestParam("username") String username,
                              @RequestParam("password") String password,
                              @RequestParam("password2") String password2,
                              @RequestParam("age") int age){
    
            if(!password.equals(password2)){
    
                return "两次密码不相同,注册失败!!";
            }else {
                int res = userLoginService.adduser(username,password,age);
                if(res == 0){
                    return "注册失败!";
                }else {
                    return "注册成功!";
                }
            }
    
        }
    }
    

    由于有同学问我要源码,有时候我可能看不见消息,所以将源码在百度云中分享出来,大家根据自己需要,自行下载吧,如果有什么建议就评论吧:

    链接:https://pan.baidu.com/s/1aGgbj4ahZdero4kKOOZByw 
    提取码:vtox 
     


     

    如果文中有错误,希望能够指出,一同进步!

    展开全文
  • SpringBoot整合MyBatis的步骤

    万次阅读 2021-03-04 15:21:07
    目录MyBatis 整合包编写接口和xml编写配置文件 application.properties编写 controller 测试使用所有依赖 MyBatis 整合包 <!-- Mybatis ...

    项目环境

    开发工具:Intellij IDEA 2020.2.1
    springboot:2.4.3
    jdk:1.8.0_251
    maven:3.6.3


    第1步 导入MyBatis 整合包

    <!-- Mybatis https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
    <dependency>
    	<groupId>org.mybatis.spring.boot</groupId>
    	<artifactId>mybatis-spring-boot-starter</artifactId>
    	<version>2.1.1</version>
    </dependency>
    


    第2步 编写接口和xml

    目录结构, 注意 mapper 包和 resources 目录下的 /mybatis/mapper 目录
    在这里插入图片描述

    第一 在 com/pro/ 目录新增 mapper 包

    然后在 com/pro/mapper 包下新增 UsersMapper 接口

    package com.pro.mapper;
    
    import com.pro.pojo.Users;
    import org.apache.ibatis.annotations.Mapper;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    
    @Mapper
    @Repository
    public interface UsersMapper {
        // 查询所有用户
        List<Users> queryUserList();
    
        Users queryUserById(int id);
        
        int addUser(Users users);
        
        int updateUser(Users users);
    
        int deleteUser(int id);
    }
    

    第二 在 resources 目录下新增目录 /mybatis/mapper

    然后在 resources/mybatis/mapper 目录新增 UsersMapper.xml 文件

    注意 namespace 需要绑定接口

    <?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.pro.mapper.UsersMapper">
        <select id="queryUserList" resultType="Users">
            select * from users
        </select>
    
        <select id="queryUserById" parameterType="int" resultType="Users">
            select * from users where id = #{id}
        </select>
    
        <insert id="addUser" parameterType="Users">
            insert into users(name, pwd) values(#{name},#{pwd})
        </insert>
    
        <update id="updateUser" parameterType="Users">
            update users set name = #{name}, pwd = #{pwd} where id = #{id}
        </update>
    
        <delete id="deleteUser" parameterType="int">
            delete from users where id = #{id}
        </delete>
    </mapper>
    


    第3步 编写配置文件 application.properties

    注意 因为我把 xml 写在了 resources 目录下了, 所以这里 mybatis.mapper-locations 属性对应了这个路径 classpath:mybatis/mapper/*.xml

    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    
    # 整合 MyBatis 配置
    # 别名
    mybatis.type-aliases-package=com.pro.pojo
    # 绑定 mapper.xml
    mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
    


    第4步 编写 controller 测试使用

    在 com/pro/ 目录新增 controller 包, 编写 UsersController 类进行测试

    为了方便测试, 这里就没有写 services 层了, 直接在 controller 层调用了

    package com.pro.controller;
    
    import com.pro.mapper.UsersMapper;
    import com.pro.pojo.Users;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    
    @RestController
    public class UsersController {
        @Autowired
        private UsersMapper usersMapper;
    
        @GetMapping("/user/list")
        public List<Users> queryUserList() {
            List<Users> users = usersMapper.queryUserList();
    
            return users;
        }
    
        @GetMapping("/user/add")
        public Object addUser() {
            Users users = new Users(null, "ControllerAddUser", "add123");
    
            int i = usersMapper.addUser(users);
            if (i > 0) {
                return "新增成功";
            }
    
            return "新增失败";
        }
    
        @GetMapping("/user/{id}")
        public Object deleteUser(@PathVariable("id") int id) {
    
            int i = usersMapper.deleteUser(id);
            if (i > 0) {
                return "删除成功";
            }
    
            return "删除失败";
        }
    }
    

    启动项目, 测试访问 http://localhost:8080/user/list 成功

    在这里插入图片描述

    所有依赖

    <!--web-->
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Mybatis https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
    <dependency>
    	<groupId>org.mybatis.spring.boot</groupId>
    	<artifactId>mybatis-spring-boot-starter</artifactId>
    	<version>2.1.1</version>
    </dependency>
    
    <dependency>
    	<groupId>org.projectlombok</groupId>
    	<artifactId>lombok</artifactId>
    </dependency>
    
    <!--数据库驱动-->
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
    	<groupId>mysql</groupId>
    	<artifactId>mysql-connector-java</artifactId>
    	<scope>runtime</scope>
    </dependency>
    
    展开全文
  • springboot整合mybatis配置

    万次阅读 2019-01-03 21:11:56
    springboot整合mybatis配置 本文只说明在springboot中配置mybatis,不涉及springboot的创建。 首先pom依赖 &lt;dependency&gt; &lt;groupId&gt;mysql&lt;/groupId&gt; &lt;artifactId...
  • SpringBoot非官方教程 | 第六篇:springboot整合mybatis

    万次阅读 多人点赞 2017-04-25 23:25:54
    本文主要讲解如何在springboot下整合mybatis,并访问数据库。由于mybatis这个框架太过于流行,所以我就不讲解了。
  • SpringBoot 整合 Mybatis

    万次阅读 2020-12-17 09:08:01
    SpringBoot Mybatis 整合 SpringBoot Mybatis这么有名的框架废话不多说了,直接开始 环境/版本一览: 开发工具:Intellij IDEA 2020.2.3 springboot:2.3.7.RELEASE jdk:1.8.0_211 maven:3.6.3 工程结构: ...
  • Spring整合Mybatis

    热门讨论 2014-05-15 00:28:26
    Spring整合Mybatis,工程可直接运行,包括jar包,全模板编程,完美分页
  • SpringBoot整合MyBatis

    2021-03-15 14:33:55
    既然SpringBoot简单易用,它如何配置整合MyBatis呢。 MyBatis-Spring-Boot-Starter MyBatis-Spring-Boot-Starter类似一个中间件,链接Spring Boot和MyBatis,构建基于Spring Boot的MyBatis应用
  • Spring整合MyBatis

    千次阅读 2019-11-15 15:13:33
    使用Spring整合MyBatis,需要将MyBatis的管理权交给Spring管理,也就是将MyBatis的SqlSessionFactory交由Spring,如果需要将SqlSessionFactory交给Spring管理,一共有三种方法: 一、让DAO层实现类继承...
  • SpringBoot整合Mybatis-Plus

    万次阅读 2018-07-20 15:46:15
    这篇文章介绍一个SpringBoot整合Mybatis-Plus,提供一个小的Demo供大家参考。 已经很久没有写文章了,最近家里有点事刚刚处理完,顺便也趁机休息了一段时间。刚回到公司看了一下码云,发现本期码云封面人员就是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,478
精华内容 24,991
关键字:

整合mybatis