使用IDEA搭建Springboot项目（dao层使用Mybatis）

最新推荐文章于 2024-10-18 16:12:31 发布

少年的白日梦

最新推荐文章于 2024-10-18 16:12:31 发布

阅读量1.6k

点赞数 2

分类专栏： Springboot 文章标签： mybatis log4j2 spring java

本文链接：https://blog.csdn.net/qq_38310244/article/details/107184039

版权

Springboot 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

使用IDEA搭建Springboot项目（dao层使用Mybatis）

好久没有写博客了。今天来简单记录一下使用IDEA工具来搭建Springboot项目的过程。

第一步创建工程

在这里插入图片描述
选择Maven项目，点击next

填写好GroupId（组织名，通常是用公司域名）和ArtifactId（项目名）然后直接next

第二步 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.admin</groupId>
    <artifactId>mywork</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>

    <properties>
        <!--指定java版本-->
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
    	<!--SpringMvc支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
             <version>2.1.3.RELEASE</version>
            <!--移除原有的log依赖-->
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--Mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--通用Mapper-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.3</version>
        </dependency>
        
        <!--log4j日志-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
    </dependencies>

</project>

第三步配置项目文件

首先需要新建一个名为application.yaml的文件
在这里插入图片描述
由于IDEA中没有yaml的后缀的文件，需要新建一个file文件再加上yaml后缀名。

server:
  port: 8080
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/mywork?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver
    hikari:
      idle-timeout: 60000
      maximum-pool-size: 30
      minimum-idle: 10
#开启SQL打印
mybatis:
  mapper-locations: classpath:mapper/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
logging:
  level:
    com.admin: debug

port：工程使用的端口。
datasource：数据库连接信息。
username：数据库的用户名。
password：数据库的密码。
url：数据库连接地址。
driver-class-name：使用的数据库连接驱动。
hikari：连接池，springboot默认支持。
mybatis：mybatis的配置
mapper-locations：需要扫描的mybatis的xml文件
logging：日志。

这里说一下：

如果在url后面不跟?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC

会报You must configure either the server or JDBC driver (via the serverTimezone configuration property)的错误。
简单解析一下这堆是啥玩意

?serverTimezone=UTC 表示的是统一标准的世界时间
?useUnicode=true&characterEncoding=UTF-8 是解决中文乱码的问题
两者结合是最好的选择

第四步创建实体类

创建一个user的实体类。

@Data
@Table(name = "user")
public class User {

    /**
     * @id 标识主键
     * @KeySql(useGeneratedKeys = true) 主键自动递增
     * @Table 映射的数据库表名
     * @Data 可省略getter和setter的书写
     */
    @Id
    @KeySql(useGeneratedKeys = true)
    private Integer id;

    private String userName;

    private String password;

    private Integer age;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

第五步创建Service层

创建service接口类

import com.admin.model.User;

public interface UserService {

    User getUserById(Integer userId);
}

创建service层的实现类

import com.admin.mapper.UserMapper;
import com.admin.model.User;
import com.admin.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("UserService")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public User getUserById(Integer userId) {
        return userMapper.getUserById(userId);
    }
}

第六步创建Mapper层接口和xml映射文件

创建Mapper层接口

import com.admin.model.User;
import org.apache.ibatis.annotations.Mapper;
import tk.mybatis.mapper.common.BaseMapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
    User getUserById(Integer userId);
}

创建mapper层的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.admin.mapper.UserMapper">
    <resultMap id="BaseResult" type="com.admin.model.User">
        <id column="id" jdbcType="INTEGER" property="id"></id>
        <result column="userName" jdbcType="VARCHAR" property="userName"></result>
        <result column="password" jdbcType="VARCHAR" property="password"></result>
        <result column="age" jdbcType="INTEGER" property="age"></result>
    </resultMap>

    <sql id="Base_Column_List">
        id,userName,password,age
    </sql>

    <select id="getUserById" resultMap="BaseResult">
        SELECT <include refid="Base_Column_List"/> FROM user WHERE id = #{userId}
    </select>
</mapper>

第七步创建Controller层

import com.admin.model.JsonResult;
import com.admin.model.StatusCode;
import com.admin.model.User;
import com.admin.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.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/user")
public class UserController {

    private final static Logger logger = LoggerFactory.getLogger(UserController.class);

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/getUserById/{userId}")
    @ResponseBody
    public JsonResult getUserById(@PathVariable Integer userId){
        User user = userService.getUserById(userId);
        logger.info("查询成功：{}",user.toString());
        return new JsonResult(StatusCode.SUCCESS,"查询成功",user);
    }
}

第九步创建启动类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AdminApplication {

    private static final Logger logger = LoggerFactory.getLogger(AdminApplication.class);

    public static void main(String[] arg){
        SpringApplication.run(AdminApplication.class,arg);
        logger.info("AdminApplication start success!");
    }
}

注意：这里使用的logger日志是slf4j2。

第十步创建log4j2.xml

在resource目录下创建log4j2.xml文件（与application.yaml同级）

<?xml version="1.0" encoding="UTF-8"?>
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
<configuration monitorInterval="5">
    <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->

    <!--变量配置-->
    <Properties>
        <!-- 格式化输出：%date表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
        <!-- %logger{36} 表示 Logger 名字最长36个字符 -->
        <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
        <!-- 定义日志存储的路径 -->
        <property name="FILE_PATH" value="E:/Gitee Project/TestApi/src/main/resources/log" />
        <property name="FILE_NAME" value="TestApi" />
    </Properties>

    <appenders>

        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <!--控制台只输出level及其以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        </console>

        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用-->
        <File name="Filelog" fileName="${FILE_PATH}/test.log" append="false">
            <PatternLayout pattern="${LOG_PATTERN}"/>
        </File>

        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的warn及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的error及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

    </appenders>

    <!--Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。-->
    <!--然后定义loggers，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>

        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <logger name="org.mybatis" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </logger>
        <!--监控系统信息-->
        <!--若是additivity设为false，则 子Logger 只会在自己的appender里输出，而不会在 父Logger 的appender里输出。-->
        <Logger name="org.springframework" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </Logger>

        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="Filelog"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>

</configuration>

项目总体结构

在这里插入图片描述

测试

使用postman测试结果
在这里插入图片描述
到这里，一个简单的Springboot项目就搭建好了，后期需要进行进一步的改进和完善。
项目GitHub地址：https://github.com/RunningDuck/Springboot.git

写在最后的话

实习了半年后发现，在工作中很少会去关注底层的实现原理，但是底层的实现原理却是往上高攀更高技术的基础。虽然在平时工作中会使用到很多的技术，比如redis、Nginx、kafka、线程池、jpa等等，但也只是停留在用，没有去深入的了解这样用或者那样用会有什么后果。所以，如果有时间还是多看看底层原理的好。

学无止境，一分耕耘一分收获。