Mybatis

最新推荐文章于 2024-07-15 22:27:18 发布
最新推荐文章于 2024-07-15 22:27:18 发布
阅读量71 收藏
点赞数 1
分类专栏： 笔记 文章标签： java intellij-idea maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53323393/article/details/125125540
版权

Mybatis

1、简介

基于Java的持久层框架

  • Maven仓库:https://mvnrepository.com/
<!--mybatis-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>
  • Github:https://github.com/mybatis/mybatis-3/releases
  • 中文文档:https://mybatis.org/mybatis-3/zh/getting-started.html

2、核心配置文件

1.XML 配置文件：

  • 包括获取数据库连接实例的数据源（DataSource）
  • 决定事务作用域
  • 控制方式的事务管理器（TransactionManager）
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
     <!--引入外部配置文件-->
    <properties resource="db.properties"/>
    
    <!--可以配置多套环境-->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
</configuration>

2.基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的:

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// SqlSessionFactoryBuilder 则可以从 XML 配置文件来构建出 SqlSessionFactory 实例
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

将其封装为工具类：

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            //使用MyBatis加载资源获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession(){
        //sqlSessionFactory获得sqlSession实例(sqlSession可以理解为preparedStatement)
        return sqlSessionFactory.openSession();
    }

}

3.编写实体类对应接口：

import com.xiong.pojo.User;

import java.util.List;

public interface UserMapper {

    List<User> getUserList();
}

4.基于 XML 映射语句:

接口实现，对应原来的UserMapperImpl类

<?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">
<!--通过namespace绑定一个对应的接口-->
<mapper namespace="com.xiong.UserMapper">
    <!--id对应接口类中方法的名字-->
      <select id="getUserList" resultType="com.xiong.pojo.User">
        select * from mybatis.user;
    </select>
</mapper>

5.将Mapper.xml文件在核心配置中注册

<!--在mybatis-config.xml文件中加入-->
    <mappers>
        <mapper resource="com/xiong/dao/UserMapper.xml"/>
    </mappers>

6.利用junit测试

public class UserDaoTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        
        //方式一：getMapper
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        
        //方式二：(不推荐使用)
 	//List<User> userList=sqlSession.selectList("com.xiong.dao.UserDao.getUserList");
        
        List<User> userList = userDao.getUserList();

        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
}

7.问题：maven资源过滤

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

3、CRUD

1.编写UserMapper接口类

package com.xiong.dao;

import com.xiong.pojo.User;

import java.util.List;
import java.util.Map;

public interface UserMapper {

    //模糊查询
    List<User> getUserList(String value);

    //查询全部用户
    List<User> getList();

    //根据ID查询用户
    User getUserById(int id);

    User getUserById2(Map<String,Object> map);

    //添加用户
    int addUser(User user);

    //利用Map存储
    int addUser2(Map<String,Object> map);

    //修改用户
    int updateUser(User user);

    //删除用户
    int deleteUser(int id);

}

2.编写基于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.xiong.dao.UserMapper">

    <select id="getUserList" resultType="com.xiong.pojo.User">
        select * from mybatis.user where name like #{value}
    </select>

    <select id="getList" resultType="com.xiong.pojo.User">
        select * from mybatis.user
    </select>

    <select id="getUserById" parameterType="int" resultType="com.xiong.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>

    <select id="getUserById2" parameterType="map" resultType="com.xiong.pojo.User">
        select * from mybatis.user where id = #{id} and name = #{name}
    </select>

    <insert id="addUser" parameterType="com.xiong.pojo.User">
        insert into mybatis.user (id,`name`,pwd) values (#{id},#{name},#{pwd})
    </insert>

    
    <!--万能的map （利用map解决实体类字段过多问题）-->
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user (id,pwd) values (#{userid},#{userpwd})
    </insert>

    <update id="updateUser" parameterType="com.xiong.pojo.User">
        update mybatis.user
        set name = #{name},pwd = #{pwd}
        where id = #{id};
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id = #{id}
    </delete>
    
</mapper>

Map传递参数，直接在sql中取出key即可！（paramterType=“map”）

对象传递参数，直接在sql总取对象的属性即可！(paramterType=“Object”)

只有一个基本类型的参数的情况下，可以直接在sql中取到！

4、配置解析

4.1、类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写

    <typeAliases>
        <!--给实体类起别名-->
        <typeAlias type="com.xiong.pojo.User" alias="User"/>
        <!--扫描包中的类，默认别名为这个类首字母小写-->
        <!--<package name="com.xiong.pojo"/>-->
    </typeAliases>

若有注解，则别名为其注解值

@Alias("user")
public class User {
    ...
}

4.2、设置(settings)

开启缓存：cacheEnabled

延迟加载：lazyLoadingEnabled

指定 MyBatis 所用日志：logImpl

驼峰命名自动映射：mapUnderscoreToCamelCase

4.3、映射器(mappers)

MapperReegistry:注册绑定Mapper文件;

方式一：

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册-->
<mappers>
   <mapper resource="com/xiong/dao/UserMapper.xml"/>
</mappers>

方式二：使用class文件绑定注册

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册-->
<mappers>
   <mapper class="com.xiong.dao.UserMapper"/>
</mappers>

​ 注意点：

  • 接口和它的Mapper配置文件必须同名
  • 接口和它的Mapper配置文件必须在同一个包下

方式三:使用扫描包进行注册

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册-->
<mappers>
   <package name="com.xiong.dao"/>
</mappers>

注意点：

  • 接口和它的Mapper配置文件必须同名
  • 接口和它的Mapper配置文件必须在同一个包下

4.4、生命周期和作用域

作用域和生命周期类别是至关重要的，错误的使用会导致非常严重的并发问题

SqlSessionFactoryBuilder：

  • 一旦创建了SqlSessionFactory,就不需要了
  • 局部变量

SqlSessionFactory：

  • 可以理解为数据库连接池
  • 一旦创建就应该在运行期间一直存在
  • 作用域是应用作用域
  • 使用单例模式或者静态单例模式

SqlSession：

  • 可以理解为连接到连接池的一个请求
  • 其实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
  • 需要开启和关闭，否则资源被占用

5、ResultMap

解决属性名和字段名不一致的问题

实体类中属性为 password

public class User {
    private int id;
    private String name;
    private String password;
}

//数据库中对应字段为 id name pwd

通过id查询结果中 password = null

 select * from mybatis.user where id = #{id}

//类型处理器解析为
 select id,name,pwd from mybatis.user where id = #{id}

解决方法：

  • 起别名
 <select id="getUserById" parameterType="int" resultType="User">
        select id,name,pwd as password from mybatis.user where id = #{id}
 </select>
  • resultMap结果集映射
<!--将UserMap结果集映射为User-->
<resultMap id="UserMap" type="User">
    <!--column数据库中的字段，property实体类中的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>

<select id="getUserById" resultMap="UserMap">
    select * from mybatis.user where id = #{id}
</select>

6、日志

6.1、日志工厂

SLF4J

LOG4J

LOG4J2

JDK_LOGGING

COMMONS_LOGGING

STDOUT_LOGGING（标准日志输出）

NO_LOGGING

<!--不可以修改，官网上的值，不可以加空格-->
<settings>
    <!--标准日志工厂实现-->
	<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

6.2、LOG4J

  • 可以控制日志的输出格式
  • 可以通过配置文件来配置日志

依赖：

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependencies>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

配置文件 log4j.perperties：

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPatten=[%c]-%m%n

#文件输出相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/xiong.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

若要在输出日志的类加入相关语句，则需要定义属性在相应方法中使用：

import org.apache.log4j.Logger;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;

public class MybatisTest {

    //参数为当前类的class
    static Logger logger = Logger.getLogger(MybatisTest.class);
    
    @Test
    public void TestLog4j(){
        logger.info("info:进入了testLog4j");
        logger.debug("debug:进入了testLog4j");
        logger.error("error:进入了testLog4j");
    }

}

7、分页

通过分页减少数据的处理量

7.1、Limit分页

语法：select * from user limit startIndex,pageSize;
select * from user limit 3;  #[0,n]


<!--Limit分页-->
<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
    select * from mybatis.user limit #{startIndex},#{pageSize}
</select>


@Test
public void getUserByLimit(){
    SqlSession sqlSession = MybatisUtil.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    HashMap<String, Integer> map = new HashMap<String,Integer>();
    map.put("startIndex",0);
    map.put("pageSize",2);
    List<User> userByLimit = mapper.getUserByLimit(map);

    for (User user : userByLimit) {
        System.out.println(user);
    }

    sqlSession.close();
}

7.2、RowBounds分页

    <!--RowBounds分页-->
    <select id="getUserByRowBounds" resultMap="UserMap">
        select * from mybatis.user
    </select>


    @Test
    public void getUserByRowBounds(){
        SqlSession sqlSession = MybatisUtil.getSqlSession();

        //RowBounds实现分页
        RowBounds rowBounds = new RowBounds(1,2);

        //通过Java代码层面实现分页
        List<User> userList = sqlSession.selectList("com.xiong.dao.UserMapper.getUserByRowBounds",null,rowBounds);

        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

7.3、分页插件

Mybatis-PageHelper

8、注解开发

面向接口编程：解耦，定义与实现的分离

本质为：反射机制

底层为：动态代理

使用注解开发，映射语句可以不用xml来配置！

public interface UserMapper {

    //根据ID查询用户
    @Select("select * from mybatis.user")
    List<User> getUserList();

    @Select("select * from user where id = #{id} and name = #{name}")
    //多个参数时加上@Param
    User getUserByID(@Param("id") int id,@Param("name") String name);

    @Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);

    @Delete("delete from user where id = #{uid}")
    int deleteUser(@Param("uid") int id);

}

9、执行流程

  1. Resources对象获取加载全局配置文件
  2. 实例化SqlSessionFactoryBuilder
  3. 通过XMLConfigBuilder解析流，环境，配置文件
  4. 所有解析信息放入Configuration
  5. 实例化SqlSessionFactory
  6. Transactional事务管理器
  7. 创建executor执行器（核心对象）
  8. 创建sqlSession
  9. 实现CRUD （若事务出现问题，回滚，至6事务管理器）
  10. 检查是否执行成功（失败，至6事务管理器）
  11. 提交事务
  12. 关闭sqlSession

10、多对一处理

10.1、按照查询嵌套处理

<!--查询所有学生信息
	根据查询学生信息的tid，寻找对应的老师
-->
<select id="getStudentList" resultMap="StudentT">
    select * from student
</select>

<resultMap id="StudentT" type="com.xiong.pojo.Student">
    <!--复杂的属性需要单独处理，对象：association 集合:collection-->
    <association property="teacher" column="tid" javaType="com.xiong.pojo.Teacher" select="getTeacher"/>
</resultMap>

<select id="getTeacher" resultType="com.xiong.pojo.Teacher">
    select * from teacher
</select>

10.2、按照结果嵌套处理

<select id="getStudentList2" resultMap="StudentTeacher">
    select s.id sid,s.name sname,t.name tname
    from student s,teacher t
    where s.tid = t.id
</select>
<resultMap id="StudentTeacher" type="com.xiong.pojo.Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" javaType="com.xiong.pojo.Teacher">
        <result property="id" column="id"/>
        <result property="name" column="tname"/>
    </association>
</resultMap>

11、一对多处理

11.1、按查询嵌套处理

    <select id="getTeacher2" resultMap="TeacherStudent">
        select * from teacher where id = #{tid}
    </select>

    <resultMap id="TeacherStudent" type="com.xiong.pojo.Teacher">
        <collection property="students" javaType="ArrayList" ofType="com.xiong.pojo.Student" select="getStudent" column="id"/>
    </resultMap>

    <select id="getStudent" resultType="com.xiong.pojo.Student">
        select * from student where tid = #{tid}
    </select>

11.2、按结果嵌套处理

<select id="getTeacher" resultMap="TeacherS">
    select t.id tid,t.name tname,s.id sid,s.name sname
    from teacher t,student s
    where t.id = s.tid and t.id=#{tid}
</select>

<resultMap id="TeacherS" type="com.xiong.pojo.Teacher">
    <result property="id" column="tid"/>
    <result property="name" column="tname"/>
    <collection property="students" ofType="com.xiong.pojo.Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection>
</resultMap>

12、动态SQL

动态SQL是指根据不同的条件生成不同的SQL语句

12.1、if

<select id="queryBlogIf" parameterType="map" resultType="com.xiong.pojo.Blog">
    select * from blog
    <where>
        <if test="title != null">
            title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </where>
</select>

也可以使用引用片段，实现SQL语句的复用

<sql id="if-title">
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</sql>



<select id="queryBlogIf" parameterType="map" resultType="com.xiong.pojo.Blog">
    select * from blog
    <where>
        <include refid="if-title"></include>
    </where>
</select>

12.2、choose

<!--choose：类似于JAVA中的Switch语句-->
<select id="queryBlogChoose" parameterType="map" resultType="com.xiong.pojo.Blog">
    select * from blog
    <where>
        <choose>
            <when test="title != null">
                title = #{title}
            </when>
            <when test="author != null">
                and title=#{title}
            </when>
            <otherwise>
                and views = #{views}
            </otherwise>
        </choose>
    </where>
</select>

12.3、set

<update id="updateBlog" parameterType="map">
    update blog
    <set>
        <if test="title != null">
            title = #{title},
        </if>
        <if test="author !=null">
            author = #{author},
        </if>
    </set>
    where id = #{id}
</update>

12.4、foreach

<!--select * from blog where 1=1 and (id=1 or id=2 or id=3)-->
<select id="queryBlogForeach" parameterType="map" resultType="com.xiong.pojo.Blog">
    select * from blog
    <where>
        <!--collection传入的集合  item迭代项   separator分隔符-->
        <foreach collection="idList" item="id" open="and (" separator="or" close=")">
            id=#{id}
        </foreach>
    </where>
</select>

13、缓存

主从复制：保证数据库之间数据的一致性

读写问题：利用缓存来将数据库读写分离，从而解决一定的并发问题

7.1、一级缓存

本地缓存，sqlSession级别

  • 与数据库同一次会话期间查到的数据会放在本地缓存
  • 若下次继续访问该数据，不会再去数据库查询而是直接从缓存中拿取

缓存失效：

  • 查询不同的内容
  • 增删改可能会改变原来数据库的内容，故该操作后需要刷新缓存(在两条查询语句中间添加增删改语句)
  • 查询不同的 *Mapper.xml
  • 手动清理缓存

一级缓存默认开启，只在一次sqlSession中有效(从拿到连接到关闭连接时间段)

7.2、二级缓存

全局缓存，namespace级别

  • 只要开启了二级缓存，同一个Mapper下就有效
  • 所有数据都会先放在一级缓存中，只有当会话提交，或者关闭的时候，才会提交到二级缓存中

7.3、缓存原理

查询时，先会去二级缓存中寻找数据，其次是一级缓存，最后是数据库中拿数据

阳光就在天上
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis增强版MyBatis-Flex介绍
沉淀、分享、成长，让自己和他人都能有所收获！
08-14 3万+
本文介绍了 Mybatis-Flex，一个用于增强 MyBatis 的框架。相对于 MyBatis-Plus，Mybatis-Flex提供了一些显著的特点，如支持联表查询以及在Mybatis-Plus中收费的功能在Mybatis-Flex中是免费的。文章概述了 MyBatis-Flex 的功能特点，并深入介绍了联表查询的不同方案。
MyBatis
weixin_45984258的博客
12-25 3205
MyBatisMyBatis快速入门Mapper代理开发MyBatis核心配置文件配置文件完成增删改查注解完成增删改查动态SQL MyBatis快速入门 MyBatis： Mybatis 是一款优秀的持久层框架，用于简化JDBC开发 JDBC的缺点： 1、硬编码： 注册驱动 SQL与君 2、操作繁琐 手动设置参数 手动封装结果集 MyBatis本是Apache的一个开源项目iBatis，2010年这个项目由apache software foundation 迁移到google code，并改名
mybatis中大于等于小于等于的写法
热门推荐
chenxingde的博客
03-04 30万+
标准写法如下：大于等于 = ]]> 小于等于 sql如下： create_date_time = ]]> #{startTime} and create_date_time #{endTime}
mybatis3.5.6
11-04
学习mybatis 不创建maven 需要下载jar包 但是在GitHub上下载实在是太慢了，有时还可能下载不了。分享一下
mybatisx.zip
11-08
这个压缩包文件“mybatisx.zip”包含了多个版本的MybatisX插件，包括MybatisX-1.4.16.zip、MybatisX-1.4.8.zip、MybatisX-1.4.6.zip以及MybatisX-1.1.2.zip。这些版本的差异可能体现在功能增强、性能优化或者修复...
mybatis慢SQL插件
07-19
基于mybatis的慢SQL小插件，原理是mybatis拦截器。只需要在springboot的配置文件做简单的配置，mybatis拦截器将SQL中所有参数自动做了填充。拦截器监控慢SQL并将完整的可执行的SQL语句打印在日志文件中，复制该SQL...
MyBatis入门.pdf
09-24
MyBatis入门 MyBatis是一个优秀的持久层框架，使用XML将SQL与程序解耦，便于维护。MyBatis学习简单，执行高效，是JDBC的延伸。MyBatis提供了数据库增删改查的便捷操作，极大提高了开发效率、统一的编码规则、利于...
mybatis demo
01-25
MyBatis是一个优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。在本示例中，"mybatis demo" 是一个基于Dubbo的MyBatis演示项目，旨在帮助开发者理解和实践如何在分布式环境中使用MyBatis进行数据访问...
java学习----递归
qq_56798493的博客
07-13 162
【代码】java学习----递归。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 787
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 626
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 866
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 995
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java 线程池详解
qq_41591215的博客
07-13 940
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
【JAVA】相关程序组件
qq_44077764的博客
07-15 140
【JAVA】相关程序组件
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 590
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
最新发布
liangzai215的专栏
07-15 495
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
MyBatis框架详解与优势
"MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使得开发者专注于SQL本身，简化了数据库操作的繁琐步骤。MyBatis通过xml或注解配置SQL语句，自动将结果映射为Java对象。" 在Java开发中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值