Spring Boot应用开发实战：druid + Mybatis框架

最新推荐文章于 2025-07-25 10:01:51 发布
原创 最新推荐文章于 2025-07-25 10:01:51 发布 · 1k 阅读 · 11 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#spring boot #spring #java

很遗憾原生的https://start.spring.io已经不在支持java8了，但对于开发人员来说，升级java版本意味着之前的项目也面临升级改造，无疑是很痛苦的。

所以这里使用了阿里的https://start.aliyun.com，但需要先安装阿里的插件alibaba-cloud-toolkit

安装后重启idea

修改本地Maven仓库地址

File->seting:

Maven执行结束后项目结构如下

需要进行一下改造：

顺便把框架用到的包添加进来：直接给出我完整的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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.my</groupId>
    <artifactId>tst</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>tst</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.7.6</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-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>2.3.0</version>
        </dependency>

        <dependency>
            <groupId>com.microsoft.sqlserver</groupId>
            <artifactId>mssql-jdbc</artifactId>
            <version>6.4.0.jre8</version>
<!--            <scope>runtime</scope>-->
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--        add-begin-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.15-beta2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.15-beta2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml-schemas</artifactId>
            <version>3.15-beta2</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-scratchpad</artifactId>
            <version>3.0.2-FINAL</version>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.8.0</version>
        </dependency>
        <dependency>
            <groupId>com.belerweb</groupId>
            <artifactId>pinyin4j</artifactId>
            <version>2.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.54</version>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.26</version>
<!--            <scope>provided</scope>-->
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <!--        add-end-->
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.my.tst.TstApplication</mainClass>
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
        <!--将resources下的文件包含到资源中-->
        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
    </build>

</project>

接下来对目录结构进行一些调整，习惯上使用yml代替了原来的properties，添加了log相关的xml配置，mapper存放数据库映射xml文件，static存放一些js、css等静态文件，templates存放html视图文件。MasterDataSourceConfig是数据库连接池的设置，dao、entity、mapper是mybatis数据库的映射文件。

 

log4j.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM
        "http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd">
<log4j:configuration debug="false" >
    <appender name="myConsole" class="org.apache.log4j.ConsoleAppender">
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[%d{dd HH:mm:ss,SSS\} %-5p] [%t] %c{2\} - %m%n"/>
        </layout>
        <!--过滤器设置输出的级别-->
        <filter class="org.apache.log4j.varia.LevelRangeFilter">
            <param name="levelMin" value="debug" />
            <param name="levelMax" value="warn" />
            <param name="AcceptOnMatch" value="true" />
        </filter>
    </appender>
    <appender name="myFile" class="org.apache.log4j.RollingFileAppender">
        <param name="File" value="D:/dubbo/logs/provider/rollingLog/dubbo.log" /><!-- 设置日志输出文件名 -->
        <!-- 设置是否在重新启动服务时，在原有日志的基础添加新日志 -->
        <param name="Append" value="true" />
        <param name="MaxFileSize" value="10MB" />
        <param name="MaxBackupIndex" value="10" />

        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%p (%c:%L)- %m%n" />
        </layout>
    </appender>

    <appender name="activexAppender" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="File" value="D:/dubbo/logs/provider/dailyLog/dubbo.log" />
        <param name="DatePattern" value="'.'yyyy-MM-dd'.log'" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[%d{MMdd HH:mm:ss SSS\} %-5p] [%t] %c{3\} - %m%n" />
        </layout>
    </appender>
    <!-- 指定logger的设置，additivity指示是否遵循缺省的继承机制-->
    <logger name="com.runway.bssp.activeXdemo" additivity="false">
        <appender-ref ref="activexAppender" />
    </logger>

    <!-- 根logger的设置-->
    <root>
        <priority value ="debug"/>
        <appender-ref ref="myConsole"/>
        <appender-ref ref="myFile"/>
    </root>
</log4j:configuration>

 logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。 -->
<configuration  scan="true" scanPeriod="10 seconds">

    <!--<include resource="org/springframework/boot/logging/logback/base.xml" />-->

    <contextName>logback</contextName>
    <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
   	<property name="log.path" value="logs" />

    <!-- 彩色日志 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>


    <!--输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
       
        <encoder>
          <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>


    <!--输出到文件-->

    <!-- 时间滚动输出 level为 DEBUG 日志 -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_debug.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志归档 -->
            <fileNamePattern>${log.path}/debug/log-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录debug级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 时间滚动输出 level为 INFO 日志 -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_info.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 时间滚动输出 level为 WARN 日志 -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_warn.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>


    <!-- 时间滚动输出 level为 ERROR 日志 -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文件的路径及文件名 -->
        <file>${log.path}/log_error.log</file>
        <!--日志文件输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文件保留天数-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <!-- 此日志文件只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!--
        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、
        以及指定<appender>。<logger>仅有一个name属性，
        一个可选的level和一个可选的addtivity属性。
        name:用来指定受此logger约束的某一个包或者具体的某一个类。
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
              还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
              如果未设置此属性，那么当前logger将会继承上级的级别。
        addtivity:是否向上级logger传递打印信息。默认是true。
    -->
    <!--<logger name="org.springframework.web" level="info"/>-->
    <!--<logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>-->
    <!--
        使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
        第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
        第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别：
     -->


    <!--
        root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
        不能设置为INHERITED或者同义词NULL。默认是DEBUG
        可以包含零个或多个元素，标识这个appender将会添加到这个logger。
    -->
	<!-- 异步输出 -->  
   <appender name="INFO_FILE_QUEUE" class="ch.qos.logback.classic.AsyncAppender">  
        <discardingThreshold>0</discardingThreshold>  
          <queueSize>1024</queueSize>  
          <appender-ref ref="INFO_FILE" /> 
    </appender>
    <!--开发环境:打印控制台-->
    <springProfile name="dev">
        <logger name="org.springframework" level="info"/>
        <logger name="springfox.documentation" level="info"/>
        <logger name="druid.sql" level="info"/>
        <logger name="io.netty" level="info"/>
        <logger name="org.hibernate" level="info"/>
        <logger name="io.lettuce" level="info"/>
        <logger name="org.apache.commons" level="info"/>
      
        <root level="debug">
	        <appender-ref ref="CONSOLE" />
	        <appender-ref ref="DEBUG_FILE" />
	        <appender-ref ref="INFO_FILE" />
	        <appender-ref ref="WARN_FILE" />
	        <appender-ref ref="ERROR_FILE" />
   		</root>
    </springProfile>

    <!--Test环境:输出到文件-->
    <springProfile name="test">
        <root level="info">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="DEBUG_FILE" />
            <appender-ref ref="INFO_FILE" />
            <appender-ref ref="ERROR_FILE" />
            <appender-ref ref="WARN_FILE" />
        </root>
    </springProfile>
 
    <!--生产环境:输出到文件-->
    <springProfile name="prod">
        <root level="info">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="DEBUG_FILE" />
            <appender-ref ref="INFO_FILE" />
            <appender-ref ref="ERROR_FILE" />
            <appender-ref ref="WARN_FILE" />
        </root>
    </springProfile>

</configuration>

application.yml

# 公共配置，一般不需要修改
server:
  port: 81
  undertow:
    # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
    # 不要设置过大，如果过大，启动项目会报错：打开文件数过多
    io-threads: 4
    # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程
    # 它的值设置取决于系统线程执行任务的阻塞系数，默认值是IO线程数*8
    worker-threads: 32
    # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
    # 每块buffer的空间大小,越小的空间被利用越充分
    buffer-size: 1024
    # 是否分配的直接内存(NIO直接分配的堆外内存)
    direct-buffers: true
spring:
  application:
    name: tst
  profiles:
    active: dev
  thymeleaf:
    prefix: classpath:/templates/
    mode: HTML
    cache: false
    encoding: UTF-8
    servlet:
      content-type: text/html
  servlet:
    multipart:
      max-file-size: -1
      max-request-size: -1
logging:
  config: classpath:logback-spring.xml

 application-dev.yml

server:
  port: 8088
master:
  datasource:
    url: jdbc:sqlserver://localhost:1433; DatabaseName=YLAdm
    driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
    username: sa
    password: 123
    druid:
      enable: true
      async-init: true # 异步初始化连接
      validation-query: SELECT 1 # 检查存活SQL，心跳检测语句
      test-while-idle: true # 开启心跳检测
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      time-between-eviction-runs-millis: 60000 # 心跳检测时间
      max-wait: 60000 # 60秒
      web-stat-filter:
        enabled: false # 关闭状态监控

USERSDao.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.my.tst.dao.USERSDao">
    <insert id="add" parameterType="com.my.tst.entity.USERS">
        insert into USERS(ACCOUNT,PASSWORD,NAME,SEX,TEL,QQ,EMAIL,IDCARD,STUT,ADDTIME,MONEY,PHOTOPATH,ID,TIP,DEPARTID) values(#{ACCOUNT},#{PASSWORD},#{NAME},#{SEX},#{TEL},#{QQ},#{EMAIL},#{IDCARD},#{STUT},#{ADDTIME},#{MONEY},#{PHOTOPATH},#{ID},#{TIP},#{DEPARTID})
    </insert>
    <delete id="delete" parameterType="String">
        delete FROM USERS WHERE ID = #{ID}
    </delete>
    <select id="getMod" resultType="com.my.tst.entity.USERS" parameterType="String">
        SELECT * FROM [USERS] WHERE [ID] = #{ID}
    </select>
    <update id="update" parameterType="com.my.tst.entity.USERS">
        update USERS set ACCOUNT=#{ACCOUNT},PASSWORD=#{PASSWORD},NAME=#{NAME},SEX=#{SEX},TEL=#{TEL},QQ=#{QQ},EMAIL=#{EMAIL},IDCARD=#{IDCARD},STUT=#{STUT},ADDTIME=#{ADDTIME},MONEY=#{MONEY},PHOTOPATH=#{PHOTOPATH},TIP=#{TIP},DEPARTID=#{DEPARTID} WHERE ID = #{ID}
    </update>
    <select id="getModBySql" resultType="com.my.tst.entity.USERS" parameterType="String">
        ${_parameter}
    </select>
    <select id="getListBySql" resultType="com.my.tst.entity.USERS" parameterType="String">
        ${_parameter}
    </select>
    <select id="getCountBySql" resultType="int" parameterType="String">
        ${_parameter}
    </select>
</mapper>

 USERSDao.java

package com.my.tst.dao;
import com.my.tst.entity.USERS;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface USERSDao {
    int add(USERS m);
    int delete(String v);
    USERS getMod(String v);
    int update(USERS m);
    USERS getModBySql(String sql);
    List<USERS> getListBySql(String sql);
    int getCountBySql(String sql);
}

USERS.java

package com.my.tst.entity;
import org.springframework.format.annotation.DateTimeFormat;
import java.math.BigDecimal;
import java.util.Date;
public class USERS {
    private String ACCOUNT;
    public String getACCOUNT(){return this.ACCOUNT;}
    public void setACCOUNT(String ACCOUNT){this.ACCOUNT=ACCOUNT;}

    private String PASSWORD;
    public String getPASSWORD(){return this.PASSWORD;}
    public void setPASSWORD(String PASSWORD){this.PASSWORD=PASSWORD;}

    private String NAME;
    public String getNAME(){return this.NAME;}
    public void setNAME(String NAME){this.NAME=NAME;}

    private String TEL;
    public String getTEL(){return this.TEL;}
    public void setTEL(String TEL){this.TEL=TEL;}

    private String QQ;
    public String getQQ(){return this.QQ;}
    public void setQQ(String QQ){this.QQ=QQ;}

    private String EMAIL;
    public String getEMAIL(){return this.EMAIL;}
    public void setEMAIL(String EMAIL){this.EMAIL=EMAIL;}

    private String IDCARD;
    public String getIDCARD(){return this.IDCARD;}
    public void setIDCARD(String IDCARD){this.IDCARD=IDCARD;}

    private int STUT;
    public int getSTUT(){return this.STUT;}
    public void setSTUT(int STUT){this.STUT=STUT;}

    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date ADDTIME;
    public Date getADDTIME(){return this.ADDTIME;}
    public void setADDTIME(Date ADDTIME){this.ADDTIME=ADDTIME;}

    private BigDecimal MONEY;
    public BigDecimal getMONEY(){return this.MONEY;}
    public void setMONEY(BigDecimal MONEY){this.MONEY=MONEY;}

    private String PHOTOPATH;
    public String getPHOTOPATH(){return this.PHOTOPATH;}
    public void setPHOTOPATH(String PHOTOPATH){this.PHOTOPATH=PHOTOPATH;}

    private String ID;
    public String getID(){return this.ID;}
    public void setID(String ID){this.ID=ID;}

    private String TIP;
    public String getTIP(){return this.TIP;}
    public void setTIP(String TIP){this.TIP=TIP;}

    private String DEPARTID;
    public String getDEPARTID(){return this.DEPARTID;}
    public void setDEPARTID(String DEPARTID){this.DEPARTID=DEPARTID;}

    public USERS (){}
}

USERSSrv.java

package com.my.tst.service;
import com.my.tst.dao.USERSDao;
import com.my.tst.entity.USERS;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class USERSSrv  extends BaseSrv {
    @Autowired
    private USERSDao usersDao;
    public int add(USERS m){return usersDao.add(m);}
    public int delete(String v){return usersDao.delete(v);}
    public USERS getMod(String v){return usersDao.getMod(v);}
    public int update(USERS m){return usersDao.update(m);}
    public USERS getModBySql(String sql){return usersDao.getModBySql(sql);}
    public List<USERS> getListBySql(String sql){return usersDao.getListBySql(sql);}
    public int getCountBySql(String sql){return usersDao.getCountBySql(sql);}
    public List<USERS> getListBySqlPage(String sql,int page,int pageSize){
        List<USERS> r=usersDao.getListBySql(sql);
        int pged = page*pageSize;
        if(pged>r.size()){pged = r.size();}
        return r.subList((page-1)*pageSize,pged);
    }
}

BaseSrv.java

package com.my.tst.service;
public class BaseSrv {
}

MasterDataSourceConfig.java

package com.my.tst.Cfg;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
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.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
// 扫描 Mapper 接口并容器管理
@MapperScan(basePackages = MasterDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "masterSqlSessionFactory")
public class MasterDataSourceConfig {
    //
    static final String PACKAGE = "com.my.tst";
    static final String MAPPER_LOCATION = "classpath:mapper/*.xml";

    @Value("${master.datasource.url}")
    private String url;

    @Value("${master.datasource.username}")
    private String user;

    @Value("${master.datasource.password}")
    private String password;

    @Value("${master.datasource.driver-class-name}")
    private String driverClass;

    @Value("${master.datasource.druid.validation-query}")
    private String validation;
    @Value("${master.datasource.druid.test-while-idle}")
    private boolean testwhilidle;
    @Value("${master.datasource.druid.test-on-borrow}")
    private boolean testonborrow;
    @Value("${master.datasource.druid.test-on-return}")
    private boolean testonreturn;
    @Value("${master.datasource.druid.time-between-eviction-runs-millis}")
    private Long timebetweenevictionrunsmillis;


    @Bean(name = "masterDataSource")
    @Primary
    public DataSource masterDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClass);
        dataSource.setUrl(url);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        dataSource.setTestOnBorrow(testonborrow);
        dataSource.setTestOnReturn(testonreturn);
        dataSource.setValidationQuery(validation);//心跳sql
        dataSource.setTestWhileIdle(testwhilidle);//开启心跳
        dataSource.setTimeBetweenEvictionRunsMillis(timebetweenevictionrunsmillis);//心跳检测时间
        return dataSource;
    }
    @Bean(name = "masterTransactionManager")
    @Primary
    public DataSourceTransactionManager masterTransactionManager() {
        return new DataSourceTransactionManager(masterDataSource());
    }
    @Bean(name = "masterSqlSessionFactory")
    @Primary
    public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource masterDataSource)
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(masterDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(MasterDataSourceConfig.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }
}

Index.java

package com.my.tst.Control;

import com.my.tst.entity.USERS;
import com.my.tst.service.USERSSrv;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;

@Controller
@RequestMapping("/")
public class Index {
    @Resource
    private USERSSrv usersrv;
    @RequestMapping("/")
    public String index(){
        return "index";
    }

    @RequestMapping("/getUser")
    @ResponseBody
    public USERS getuser(){
        USERS u = usersrv.getMod("0");
        return u;
    }

    @RequestMapping("/getUserList")
    @ResponseBody
    public List<USERS> getuserList(){
        List<USERS> ls = usersrv.getListBySqlPage("select * from USERS ",1,10);
        return  ls;
    }
}

index.html

<html>
<head>
    <title>test</title>
    <script src="/js/jquery-1.11.2.min.js"></script>
    <script>
        $(function () {
            getnm();
        })
        function getnm(){
            $.ajax({
                type:"get",
                url:"/getUser",
                data: {},
                dataType: "json",
                success: function (d) {
                    $("#msg").html(JSON.stringify(d));
                }
            })
        }
    </script>
</head>
<body>
        <h1>hello word!!!</h1>
        <div id="msg">

        </div>
    </body>
</html>

数据库我用的sqlserver2008 这里不多讲了。

运行调试看看：

在浏览器输入：http://localhost:8088

 最后是打包jar：直接用maven打包

最后我遇到的问题（有兴趣的可以看看）：运行时卡在 [main] pool.DruidDataSource - {dataSource-1} inited

springboot整合mybatis+druid（详解）
weixin_38568503的博客
11-18 1万+
一、创建一个SpringBoot项目 添加部分依赖： 二、引入相关依赖： 需要的依赖预览： 记忆方式：mysql数据库驱动–>druid数据库连接池–>mybatis进行增删改查 ①连接mysql数据库的驱动：mysql数据库驱动依赖mysql-connector-java ②使用druid和springboot整合的数据库连接池的：druid-spring-boot-starter ③进行数据库的增删改查的mybatis和springboot的整合依赖：mybatis-spring-
springboot整合Druid+mybatis
weixin_44096353的博客
08-07 1437
Druid Springboot集成Druid方案：一个是在POM中直接配置druid-spring-boot-starter，不用写任何代码；一个是配置druid，写几行代码，可以加入；在方案一基础上加入stat、wall后进行验证登录。 先献上github代码地址:https://github.com/yudiandemingzi/spring-boot-many-data-source 代码拉下来换下自己的mysql数据库地址,就可以直接运行。Druid的优点很明显,它的可视化界面可以监控Sql语句.
springboot+Druid+Mybatis
jarvis的博客
11-30 633
项目结构： pom.xml <dependencies> <!--springboot官方的启动器：spring-boot-start-XXX --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </de
SpringBoot整合Druid和Mybatis
我这孩子从小记性就不好，什么东西都要写下来才放心
07-25 7091
这里使用IntelliJIDEA2022.1.2演示个人认为IDEA用新不用旧，老有人说新版本bug多，其实呢，正在用的时候我是感知不到，相反他会在新版本修复老版本的bug，我觉得新版更好用更智能。如果你也深有其感，去拥抱新版本吧！.........
springboot整合mybatis & druid
lwj_07的博客
08-04 1490
使用springboot整合mybatis代码演示如下所示：数据库信息：数据层：（springboot整合mybatis的时候，数据层使用纯注解形式写sql语句的时候一定要加上@Mapper注解标明，要不然就会报错）实体类：（属性名要保证和数据库字段名一致，要不然查询出来的数据封装不到对象的属性当中）yml配置文件：（只需要写数据库的信息）...
spring boot 整合 druid + Mysql + Mybatis
热门推荐
习惯
05-09 1万+
本章主要介绍以下几点： 1： spring boot 整合 durid + mysql 数据连接池 2:  spring boot 整合 Mybatis  3： spring boot 配置 Mybatis pagehelper 分页插件 整备工作： 1： 数据库使用Mysql (没有Mysql 的可以到官网下载) 2： Maven   开发流程： 1： spring
Spring Boot 2.1.3 集成 MyBatis + Druid
码农小七的博客
02-23 4034
Spring Boot 集成 MyBatis + Druid 快速开发Spring Boot 简介集成SpringBoot + MyBatis + Druid 开发环境项目依赖配置文件Druid连接池集成测试集成结果 Spring Boot 简介 Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。 该框架使用了特定的...
Spring Boot整合Mybatis、Druid和Sharding-jdbc
theonlytao的博客
11-24 3368
前言 Spring Boot的出现让开发人员摆脱了繁琐的配置文件和依赖冲突，让项目搭建变得快速而便捷。而数据往往承载着项目的核心，从最原始的JDBC数据操作到Hibernate的对象关系映射框架的出现，数据库的操作变得更加灵活。Mybatis则是比Hibernate更为强大与灵活的ORM框架，本文将着重讲解Spring Boot和Mybatis、Druid和Sharding-jdbc的整合。 ...
Spring Boot + MyBatis + Druid整合实践项目
weixin_32311823的博客
10-24 1011
本文还有配套的精品资源，点击获取 简介：本示例项目"spring-boot-mybatis-druid.7z"结合了Spring Boot、MyBatis和Druid数据源，演示了在Spring Boot框架中整合这些组件来构建一个基于MySQL 5.6的应用程序。项目包含了完整配置文件、源代码、数据库脚本等，旨在帮助开发者理解和学习如何搭建、运行此类系统。关键知识点涵盖S...
微服务框架（六）Spring Boot集成Mybatis及Druid
若明天不见
08-07 1375
　　此系列文章将会描述Java框架Spring Boot、服务治理框架Dubbo、应用容器引擎Docker，及使用Spring Boot集成Dubbo、Mybatis等开源框架，其中穿插着Spring Boot中日志切面等技术的实现，然后通过gitlab-CI以持续集成为Docker镜像。 　　本文为Spring Boot集成Mybatis，包括mybatis-generator的使用 ...
Spring整合Druid
qq_24324041的专栏
12-10 2397
Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。 Druid是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和SQL解析器组成。该项目主要是为了扩展JDBC的一些限制，可以让程序员实现一些特殊的需求，比如向密钥服务请求凭证、统计SQL信息、SQL性能收集、SQL注入检查、SQL翻译等，程序员可以通过定制来实现自己需要的功能。 Druid
SpringBoot：Mybatis + Druid 数据访问
...
10-24 2674
SpringBoot：Mybatis + Druid 数据访问 文章目录SpringBoot：Mybatis + Druid 数据访问1、简介2、JDBC3、CRUD操作4、自定义数据源 DruidDataSource1、配置 Druid 数据源监控2、配置 Druid web 监控 filter5、SpringBoot 整合mybatis 1、简介 ​ 对于数据访问层，无论是SQL(关系型数据库) 还是NOSQL(非关系型数据库)，SpringBoot 底层都是采用 SpringData 的方式进行统一处
Springboot + mybatis + druid 整合 (Mysql多数据源)
czc_292的博客
01-14 2217
1. 依赖注入 <!--SpringBoot--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.5.3</version> </dependency> <!--druid连接池--
创建SpringBoot + Druid + Mybatis项目
先谢郭嘉的博客
09-28 1099
本章将讲述如何创建springboot项目，并配置好mysql数据库、druid连接池，以及mybatis的一些配置文件。
八.springboot集成mybatis+druid数据库连接池
qq_32430463的博客
02-13 1591
集成Druid 是一个高性能的数据库连接池，结合了 C3P0 和 DBCP 等连接池的优点，能够高效地管理数据库连接Druid 已经在阿里巴巴的多个生产环境中部署，经过了大规模的严苛考验，具有较高的稳定性和可靠性MyBatis 提供了灵活的 SQL 映射和定制化功能，结合 Spring Boot 的自动配置机制，可以快速搭建高效的数据访问层。
7K字详解！Spring Boot + Druid 实现监控 MySQL 性能，既简单又实用
wdj_yyds的博客
08-25 2162
我们都使用过连接池，比如，虽然HikariCP的速度稍快，但Druid能够提供强大的监控和扩展功能，也是阿里巴巴的开源项目。Druid是阿里巴巴开发的号称为监控而生的数据库连接池，在功能、性能、扩展性方面，都超过其他数据库连接池，包括等等，秒杀一切。Druid可以很好的监控DB池连接和SQL的执行情况，天生就是针对监控而生的DB连接池。Spring Boot默认数据源与。
SpringBoot_MyBatis/MyBatis入门+整合Druid基础
CodeWYX的博客
01-20 1279
SpringBoot_MyBatis/MyBatisPuls基础 什么是MyBatis MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。 MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs映射成数据库中的记录。 使用MyBatis的时候需要自己手动编写SQL语句，也有代码自动生成工具来简化开发，我一般会使用Mybatis-Plus增强工具包来简
Spring Boot 整合 MyBatis 与 Druid 数据源全流程
最新发布
m0_61261153的博客
07-25 1311
JdbcTemplate 是 Spring 框架提供的一个核心类，它对 JDBC 进行了封装，简化了 Java 代码与数据库的交互过程。作为 Spring 生态的一部分，JdbcTemplate 与 Spring Boot 有着天然的整合优势，能够帮助开发者快速实现数据库操作。
Spring Boot 整合 Mybatis 实现 Druid 多数据源配置
QiuHaoqian的博客
01-27 3325
目录1 多数据源的应⽤场景2 数据库脚本3 项目结构4 代码依赖 pom.xml配置文件数据源配置类实体类sql映射文件daosrvicecontroller启动类5 小节 1 多数据源的应⽤场景 当业务数据量达到了⼀定程 度，DBA 需要合理配置数据库资源。即配置主库的机器⾼配置，把核⼼⾼频的数据放在主库上；把次要的数据放在从库，低配置。开源节流嘛，就这个意思。把数据放在不同的数据库⾥，就需要通过不同的数据源进⾏操作数据。 这⾥我们举个 springboot-mybatis-mutil-datasour
Springboot配置mysql数据源+druid连接池，配置多数据源
初代二手码农
09-07 4220
Springboot配置mysql数据源+druid连接池，支持多数据源 一、配置mysql+druid 1、导入数据源所需jar，此处只导入了必要的，其他工具自行配置 <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

清风道长白云外

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值