mybatis+select查询纯代码分享

最新推荐文章于 2023-05-30 17:14:47 发布
最新推荐文章于 2023-05-30 17:14:47 发布
阅读量249 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28871287/article/details/106180086
版权

目录结构

maven
src-main-java-com-entity/mapper/test/utils
resources-jdbc.properties/mybatis-config.xml
pom.xml

java

entity

Category.java

package com.itqf.entity;
import java.util.List;

public class Category {

private int cId;
private String cName;
private int iId;

private Info info;

private List<Prodoct> prodocts;

public int getcId() {
    return cId;
}

public void setcId(int cId) {
    this.cId = cId;
}

public String getcName() {
    return cName;
}

public void setcName(String cName) {
    this.cName = cName;
}

public int getiId() {
    return iId;
}

public void setiId(int iId) {
    this.iId = iId;
}

public Info getInfo() {
    return info;
}

public void setInfo(Info info) {
    this.info = info;
}

public List<Prodoct> getProdocts() {
    return prodocts;
}

public void setProdocts(List<Prodoct> prodocts) {
    this.prodocts = prodocts;
}

@Override
public String toString() {
    return "Category{" +
            "cId=" + cId +
            ", cName='" + cName + '\'' +
            ", iId=" + iId +
            ", info=" + info +
            ", prodocts=" + prodocts +
            '}';
}

}

Info.java

package com.itqf.entity;

import java.util.List;

public class Info {
private int iId;
private String iInfo;
private int aId;
private List<Category> categories;

public int getiId() {
    return iId;
}

public void setiId(int iId) {
    this.iId = iId;
}

public String getiInfo() {
    return iInfo;
}

public void setiInfo(String iInfo) {
    this.iInfo = iInfo;
}

public int getaId() {
    return aId;
}

public void setaId(int aId) {
    this.aId = aId;
}

public List<Category> getCategories() {
    return categories;
}

public void setCategories(List<Category> categories) {
    this.categories = categories;
}

@Override
public String toString() {
    return "Info{" +
            "iId=" + iId +
            ", iInfo='" + iInfo + '\'' +
            ", aId=" + aId +
            ", categories=" + categories +
            '}';
}
}

Prodoct.java

package com.itqf.entity;

public class Prodoct {

private int pId;
private String pName;
private int cId;

private Category category;

public Category getCategory() {
    return category;
}

public void setCategory(Category category) {
    this.category = category;
}

public int getpId() {
    return pId;
}

public void setpId(int pId) {
    this.pId = pId;
}

public String getpName() {
    return pName;
}

public void setpName(String pName) {
    this.pName = pName;
}

public int getcId() {
    return cId;
}

public void setcId(int cId) {
    this.cId = cId;
}

@Override
public String toString() {
    return "Prodoct{" +
            "pId=" + pId +
            ", pName='" + pName + '\'' +
            ", cId=" + cId +
            ", category=" + category +
            '}';
}
}

mapper

CategoryMapper.java

package com.itqf.mapper;
import com.itqf.entity.Category;
import java.util.List;

public interface CategoryMapper {

Category selectCategoryByCid(int cid);

Category selectCategoryAndProductByCid(int cid);

Category selectCategoryAndProdoctsByCIDQ(int cid);

List<Category> selectCategoryAndProdoctsByIIDQ(int iid);

Category selectCategoryAndInfoByPIDQ(int cid);

}

CategoryMapper.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.itqf.mapper.CategoryMapper">

<!--Category selectCategoryByCid(int cid);-->
<select id="selectCategoryByCid" resultType="category">
    select * from category where c_id = #{cid}
</select>

<!--Category selectCategoryAndProductByCid(int cid);-->
<resultMap id="categorymap" type="category">
    <id column="c_id" property="cId"/>
    <collection property="prodocts" ofType="prodoct">
        <id column="p_id" property="pId"/>
    </collection>
</resultMap>
<select id="selectCategoryAndProductByCid" resultMap="categorymap">
    select c.c_id, c.c_name, c.i_id, p.p_id, p.p_name
    from category c join prodoct p on c.c_id = p.c_id
    where c.c_id = #{cid}
</select>

<!--Category selectCategoryAndProdoctsByCIDQ(int cid);-->
<resultMap id="ctq" type="category">
    <id column="c_id" property="cId"/>
    <collection property="prodocts" ofType="prodoct" column="c_id" select="com.itqf.mapper.ProdoctMapper.selectProdoctsByCID"/>
</resultMap>
<select id="selectCategoryAndProdoctsByCIDQ" resultMap="ctq">
    select * from category where c_id = #{cid}
</select>

<!--List<Category> selectCategoryAndProdoctsByIIDQ(int iid);-->
<select id="selectCategoryAndProdoctsByIIDQ" resultMap="ctq">
    select * from category where i_id = #{iid}
</select>

<!--Prodoct selectCategoryAndInfoByPIDQ(int pid);-->
<resultMap id="piq" type="category">
    <id column="c_id" property="cId"/>
    <result column="i_id" property="iId"/>
    <association property="info" javaType="info" column="i_id" select="com.itqf.mapper.InfoMapper.selectInfoByIID"/>
</resultMap>
<select id="selectCategoryAndInfoByPIDQ" resultMap="piq">
    select * from category where c_id = #{cId}
</select>
</mapper>

InfoMapper.java

package com.itqf.mapper;
import com.itqf.entity.Info;

public interface InfoMapper {

Info selectInfoByIID(int iid);

Info selectInfoAndCategoryAndProdoctsByIIDQ(int iid);

}

InfoMapper.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.itqf.mapper.InfoMapper">

<!--Info selectInfoAndCategoryAndProdoctsByIIDQ(int iid);-->
<resultMap id="infoMapQ" type="info">
    <id column="i_id" property="iId"/>
    <collection property="categories" ofType="category" column="i_id" select="com.itqf.mapper.CategoryMapper.selectCategoryAndProdoctsByIIDQ"/>
</resultMap>
<select id="selectInfoAndCategoryAndProdoctsByIIDQ" resultMap="infoMapQ">
    select * from info where i_id = #{iid};
</select>

<!--Info selectInfoByIID(int iid);-->
<select id="selectInfoByIID" resultType="info">
    select * from info where i_id = #{iId};
</select>

</mapper>

ProdoctMapper.java

package com.itqf.mapper;
import com.itqf.entity.Prodoct;
import java.util.List;

public interface ProdoctMapper {

List<Prodoct> selectProdoctsByCID(int cid);

Prodoct selectProdoctByPID(int pid);

Prodoct selectProdoctAndCategoryByPID(int pid);

Prodoct selectProdoctPIDQ(int pid);

Prodoct selectProdoctAndCategoryAndInfoByPIDQ(int pid);

}

ProdoctMapper.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.itqf.mapper.ProdoctMapper">

 <!--单表的商品查询 -->

 <select id="selectProdoctByPID" resultType="prodoct">
     select * from prodoct where p_id = #{pId}
 </select>

<!--<sql id="ps">-->
<!--     p.*,c.c_name,c.i_id-->
<!--</sql>-->

<resultMap id="prodoctmap" type="prodoct">
    <id column="p_id" property="pId"/>
    <result column="p_name" property="pName" />
    <result column="c_id" property="cId" />
    <!-- 给对象赋值  property对象属性  javatype对象的类型 -->
    <association property="category" javaType="category">
         <id column="c_id" property="cId" />
         <result  column="c_name" property="cName" />
         <result column="i_id" property="iId" />
    </association>
</resultMap>


<!--多表查询 嵌套结果集  (连接查询) -->
<select id="selectProdoctAndCategoryByPID" resultMap="prodoctmap">
     select p_id, p_name, c.c_id, c_name, i_id
              from prodoct p join category c
                 on p.c_id  = c.c_id
                        where p.p_id = #{pid}
</select>

<!--Prodoct selectProdoctPIDQ(int pid);-->
<resultMap id="qprodoctMap" type="prodoct">
    <id column="p_id" property="pId"/>
    <result column="c_id" property="cId"/>
    <association property="category" javaType="category" column="c_id" select="com.itqf.mapper.CategoryMapper.selectCategoryByCid"/>
</resultMap>
<select id="selectProdoctPIDQ" resultMap="qprodoctMap">
    select * from prodoct where p_id = #{pid}
</select>

<!--List<Prodoct> selectProdoctsByCID(int cid);-->
<select id="selectProdoctsByCID" resultType="prodoct">
    select * from prodoct where c_id = #{cid}
</select>

<!--Prodoct selectProdoctAndCategoryAndInfoByPIDQ(int pid);-->
<resultMap id="pci" type="prodoct">
    <id column="p_id" property="pId"/>
    <result column="c_id" property="cId"/>
    <association property="category" javaType="category" column="c_id" select="com.itqf.mapper.CategoryMapper.selectCategoryAndInfoByPIDQ"/>
</resultMap>
<select id="selectProdoctAndCategoryAndInfoByPIDQ" resultMap="pci">
    select * from prodoct where p_id = #{pid};
</select>

</mapper>

test

MybatisTest.java

package com.itqf.test;

import com.itqf.entity.Category;
import com.itqf.entity.Info;
import com.itqf.entity.Prodoct;
import com.itqf.mapper.CategoryMapper;
import com.itqf.mapper.InfoMapper;
import com.itqf.mapper.ProdoctMapper;
import com.itqf.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.io.IOException;

public class MybatisTest {

@Test
public void test1() throws IOException {
    //单表商品查询
    SqlSession sqlSession = MybatisUtils.openSqlsession();
    ProdoctMapper mapper = sqlSession.getMapper(ProdoctMapper.class);
    Prodoct product = mapper.selectProdoctByPID(1);
    System.out.println("product = " + product);
    MybatisUtils.commitAndClose(sqlSession);
}

@Test
public void test2() throws IOException {
    //多表商品查询
    SqlSession sqlSession = MybatisUtils.openSqlsession();
    ProdoctMapper mapper = sqlSession.getMapper(ProdoctMapper.class);
    Prodoct product = mapper.selectProdoctAndCategoryByPID(1);
    System.out.println("product = " + product);
    System.out.println("product.getCategory() = " + product.getCategory());
    MybatisUtils.commitAndClose(sqlSession);

}

@Test
public void test3() throws IOException {
    //单表查询类别
    SqlSession sqlSession = MybatisUtils.openSqlsession();
    CategoryMapper mapper = sqlSession.getMapper(CategoryMapper.class);
    Category category = mapper.selectCategoryByCid(1);
    System.out.println("category = " + category);
    MybatisUtils.commitAndClose(sqlSession);
}

@Test
public void test4() throws IOException {
    //多表查询类别
    SqlSession sqlSession = MybatisUtils.openSqlsession();
    CategoryMapper mapper = sqlSession.getMapper(CategoryMapper.class);
    Category category = mapper.selectCategoryAndProductByCid(1);
    System.out.println("category = " + category);
    MybatisUtils.commitAndClose(sqlSession);

}

@Test
public void test5() throws IOException {
    //多表查询类别
    SqlSession sqlSession = MybatisUtils.openSqlsession();
    ProdoctMapper mapper = sqlSession.getMapper(ProdoctMapper.class);
    Prodoct prodoct = mapper.selectProdoctPIDQ(1);
    System.out.println("prodoct = " + prodoct);
    MybatisUtils.commitAndClose(sqlSession);

}

@Test
public void test6() throws IOException {
    //多表查询类别
    SqlSession sqlSession = MybatisUtils.openSqlsession();
    CategoryMapper mapper = sqlSession.getMapper(CategoryMapper.class);
    Category category = mapper.selectCategoryAndProdoctsByCIDQ(1);
    System.out.println("category = " + category);
    MybatisUtils.commitAndClose(sqlSession);

}

@Test
public void test7() throws IOException {
    //多表查询类别
    SqlSession sqlSession = MybatisUtils.openSqlsession();
    InfoMapper mapper = sqlSession.getMapper(InfoMapper.class);
    Info info = mapper.selectInfoAndCategoryAndProdoctsByIIDQ(1);
    System.out.println("info = " + info);
    MybatisUtils.commitAndClose(sqlSession);

}

@Test
public void test8() throws IOException {
    //多表查询类别
    SqlSession sqlSession = MybatisUtils.openSqlsession();
    ProdoctMapper mapper = sqlSession.getMapper(ProdoctMapper.class);
    Prodoct prodoct = mapper.selectProdoctAndCategoryAndInfoByPIDQ(1);
    System.out.println("prodoct = " + prodoct);
    MybatisUtils.commitAndClose(sqlSession);
}
}

utils

MybatisUtils.java

package com.itqf.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {

private static SqlSessionFactory factory = null;

static {
    //使用ibatis的方案添加二狗子
    InputStream resourceAsStream = null;
    try {
        resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
    } catch (IOException e) {
        e.printStackTrace();
    }

    //2.创建sqlsesssionfbuiler
    SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();

    //3.创建sqlsessionfactory
    factory = factoryBuilder.build(resourceAsStream);
}

public static SqlSession openSqlsession() throws IOException {
    //4.创建sqlsesssion
    SqlSession sqlSession = factory.openSession();
    return sqlSession;
}

public static  void commitAndClose(SqlSession sqlSession){
    sqlSession.commit();
    sqlSession.close();
}
}

resources

jdbc.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql:///store
user=root
password=dong1995

mybatis-config.xml

<?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>
<!-- 配置mybati的核心属性-->
<!--读取外部的配置文件,或者直接声明外部配置文件 -->
<properties resource="jdbc.properties">
      <!-- ${key} 可以引入配置文件的内容
           可以在内部使用property标签进行声明属性!
           后面也是正常引用!
           注意:如果name和外部配置文件的命名相同!
           内部新声明会覆盖外部!

           ctrl+shit + a

           registry

           ide.suppess.double.clik 勾选上!
       -->
<!--          <property name="user" value="hehe"/>-->
</properties>



<settings>
    <!-- 告诉mybatis开启后台的sql语句输出!
     -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <setting name="returnInstanceForEmptyRow" value="false"/>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    <!-- FULL多层查询也会映射 PRE单表查询 NONE 根本不会映射 都需要手动配置-->
    <setting name="autoMappingBehavior" value="FULL"/>
</settings>



<typeAliases>
      <!-- 指定具体的类起别名 -->
	  <!--        <typeAlias type="com.itqf.entity.Account" alias="account" />-->
      <!-- 给包下的所有类起别名 默认:类的首字母小写  XxXx xxXx -->
      <!-- 不想用默认命名  @Alias  一定要加载package - name对应的包的类中-->
      <package name="com.itqf.entity"/>

</typeAliases>

<!-- 配置具体的数据库连接!-->
<!-- 可以选择当前使用的环境 数据库 -->
<environments default="dev">
    <!-- 一个数据库-->
    <environment id="dev">
        <!-- 是否需要mybatis进行事务管理 -->
        <!-- MyBatis 中有两种类型的事务管理器（也就是 type=”[JDBC|MANAGED]”）：
             jdbc:mybatis进行事务管理
             managed:mybatis放弃事务管理!

             spring+mybatis spring事务管理模块! tx!会覆盖mybatis的是事务管理模块
             mybatis后期没有必要配置事务管理!
        -->
        <transactionManager type="JDBC">
        </transactionManager>
        <!--连接的数据库的信息  driver url user password -->

        <!--
            type: UNPOOLED POOLED
            unpooled代表每次请求都创建一个连接和使用完毕销毁一个连接!(没有使用连接池!)

            driver – 这是 JDBC 驱动的 Java 类的完全限定名（并不是 JDBC 驱动中可能包含的数据源类）。
            url – 这是数据库的 JDBC URL 地址。
            username – 登录数据库的用户名。
            password – 登录数据库的密码。
            defaultTransactionIsolationLevel – 默认的连接事务隔离级别。

            POOLED:使用连接池的概念!mybatis内部封装了连接池!
                    每次获取,使用完放入连接池!这样效率更高!

                   pooled代表要使用连接池!所以他包含unpooled属性设置(数据库的基本连接信息)
                   同时也支持连接池的一些属性设置!

                   除了上述提到 UNPOOLED 下的属性外，还有更多属性用来配置 POOLED 的数据源：

                    poolMaximumActiveConnections – 在任意时间可以存在的活动（也就是正在使用）连接数量，默认值：10
                    poolMaximumIdleConnections – 任意时间可能存在的空闲连接数。
                    poolMaximumCheckoutTime – 在被强制返回之前，池中连接被检出（checked out）时间，默认值：20000 毫秒（即 20 秒）
                    poolTimeToWait – 这是一个底层设置，如果获取连接花费了相当长的时间，连接池会打印状态日志并重新尝试获取一个连接（避免在误配置的情况下一直安静的失败），默认值：20000 毫秒（即 20 秒）。
                    poolMaximumLocalBadConnectionTolerance – 这是一个关于坏连接容忍度的底层设置， 作用于每一个尝试从缓存池获取连接的线程。 如果这个线程获取到的是一个坏的连接，那么这个数据源允许这个线程尝试重新获取一个新的连接，但是这个重新尝试的次数不应该超过 poolMaximumIdleConnections 与 poolMaximumLocalBadConnectionTolerance 之和。 默认值：3 （新增于 3.4.5）
                    poolPingQuery – 发送到数据库的侦测查询，用来检验连接是否正常工作并准备接受请求。默认是“NO PING QUERY SET”，这会导致多数数据库驱动失败时带有一个恰当的错误消息。
                    poolPingEnabled – 是否启用侦测查询。若开启，需要设置 poolPingQuery 属性为一个可执行的 SQL 语句（最好是一个速度非常快的 SQL 语句），默认值：false。
                    poolPingConnectionsNotUsedFor – 配置 poolPingQuery 的频率。可以被设置为和数据库连接超时时间一样，来避免不必要的侦测，默认值：0（即所有连接每一时刻都被侦测 — 当然仅当 poolPingEnabled 为 true 时适用）。

        -->
        <dataSource type="POOLED">

             <property name="driver" value="${driver}"/>
             <property name="url" value="${url}"/>
             <property name="username" value="${user}"/>
             <property name="password" value="${password}"/>

        </dataSource>
    </environment>

</environments>

 <!-- 将mapper中sql语句和mybatis的核心类连接到!-->
 <mappers>
     <!--每次只找到一个mapper.xml -->
	<!--         <mapper resource="com/itqf/mapper/AccountMapper.xml" />-->

     <!-- 如果使用扫描!要求接口和mapper.xml命名必须一致-->
     <package name="com.itqf.mapper"/>
     
 </mappers>

</configuration>

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.itqf</groupId>
<artifactId>mybatis1031</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.48</version>
    </dependency>

    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.2.4</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

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

</project>
WisemanDong
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
（五）MyBatis映射器—select元素（查询语句）
青衣煮茶
03-13 3593
在映射器中select元素代表SQL的select语句，用于查询。在SQL中，select语句是用的最多的语句。在MyBatis中select也是非常关键的，也是用的最多的元素，因为它在性能上的强大，同时也和其他的持久层框架产生的差距。 select元素的配置 元素 说明 备注 id 它和Mapper的命名空间组合起来是唯一的， 供MyBatis调用 如果命名空间和...
Mybatis Mapper XML文件-查询（select）
最新发布
hay23455的博客
12-20 2287
MyBatis真正的力量在于映射语句（Mapped Statements）。这是魔力发生的地方。尽管拥有强大的功能，Mapper XML文件相对来说比较简单。如果将其与等效的JDBC代码进行比较，您会立即看到代码减少了95%。MyBatis专注于SQL的编写，并尽最大努力不干扰您的方式。
MyBatis Mapper中 @Select注解调用静态常量
java李阳勇的博客
05-30 1211
Java项目在使用MyBatis技术，辟邪mapper SQL时，如果在其中的ognl表达式或者sql中直接使用一些数字或者字符串的话，会造成难以维护的问题。在Java编码中，我们通常会把这些数字或者字符串定义在常量类或者接口中，可以直接在mapper中也可以使用这些常量就比较好。MybBatis@Select注解标签直接编写SQL,也是支持这样的需求的。包名：com.yt.nbdt.adcenter.controller.vo。mapper @Select注解使用。
通用Mapper的select(T t)的使用
sinat_36038529的博客
02-17 1375
通用mapper类： public interface CategoryMapper extends Mapper<Category> { } 使用select(T t) public List<Category> queryCategoryListByParentId(Long pid) { // select(T t) 将对象c中的非空字段当作查询的条件参数 Category record = new Category(); record.setParentId(pid)
通用Mapper各种方法及说明
weixin_45941064的博客
04-25 4504
基础接口 Select 接口： SelectMapper 方法： List select(T record); 解释： 根据实体中的属性值进行查询，查询条件使用等号 接口： SelectByPrimaryKeyMapper 方法： T selectByPrimaryKey(Object key); 解释： 根据主键字段进行查询，方法参数必须包含完整的主键属性，查询条件使用等号 接口： SelectAllMapper 方法： List selectAll(); 解释： 查询全部结果，se
SpringBoot+mybatis+Oracle整合代码
08-29
在"SpringBoot+mybatis+Oracle整合代码"中，我们可以学习到以下几个关键知识点： 1. **SpringBoot的自动配置**：SpringBoot的核心特性之一就是自动配置，它能根据项目中的依赖自动配置相应的Bean。在整合MyBatis时...
springboot+mybatis+sqlserver
04-12
【标题】"springboot+mybatis+sqlserver"是一个基于Spring Boot、MyBatis和Microsoft SQL Server构建的基础开发框架，适用于快速开发企业级应用。这个框架整合了三个关键组件，旨在简化开发流程，提高开发效率。 ...
springmvc+mybatis+maven完整项目代码
07-25
springmvc+mybatis+maven完整项目代码,麻雀虽小，五脏俱全。该项目可以说是当前目前最主流，性价比最好的web框架了，也就是SSM框,下载后可直接导入eclipse运行，代码中还包含了mybatis自动生成配置文件。珍藏，忍痛...
基于SpringBoot + MyBatis + Layui的后台权限管理系统.zip
07-08
基于SpringBoot + MyBatis + Layui的后台权限管理系统。代码简洁易懂、界面美观大方，内部封装了权限管理系统常用的全部功能，可直接作为快速开发JavaWeb项目的脚手架使用。 基于SpringBoot + MyBatis + Layui的...
springboot+mybatis+sqlserver 仓库管理系统
05-27
《SpringBoot+Mybatis+SQLServer构建的仓库管理系统详解》 在现代企业信息化管理中，仓库管理系统扮演着至关重要的角色，它能够有效地管理和追踪库存，提高运营效率。本项目是基于SpringBoot框架，结合Mybatis持久...
mybatis 关联查询完整代码
02-05
mybatis 关联查询 一对一 一对多 ResultMap association collection 完整代码
java spring boot 完全纯代码配置mybatis，解放xml
Gogym的博客
10-29 1244
Mybatis是一个使用广泛的ORM框架，相信大家都使用的很熟练的。但绝大部分朋友应该都使用XML进行配置。在springboot中，为了方便或者减少xml文件的数量，也可以选择完全通过代码来配置mybatis。下面就来说说如果通过java代码配置mybatis。 配置起来也非常简单，只需一个类，而且不容易出错。 首先把原来配置mybatis的xml文件删除，然后添加下面这个类： 通过spr...
Mybatis映射器之select解析
渔潭的博客
05-09 5407
Mybatis映射器之select解析 1. 映射器概述 MyBatis 的真正强大在于它的映射语句，也是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 就是针对 SQL 构建的轻量级的框架，并且通过配置生成对应的JavaBean返回给调用者，并且比普通的方法做的更好...
MyBatis（4）——Mapper映射文件_SELECT
星_陨的博客
12-26 936
查询语句是 MyBatis 中最常用的元素之一，光能把数据存到数据库中价值并不大，如果还能重新取出来才有用，多数应用也都是查询比修改要频繁。 &lt;select &gt; &lt;/select&gt;标签属性参考表： Select Attributes 属性 描述 id 在命名空间中唯一的标识符，可以被用来引用这条语句。 parameterType 将会传入这条...
Mybatis的基本增删改查（代码）
qq_41220595的博客
05-26 192
3、CRUD增删改查 3.1、namespace namespace中的包名要和Mapper接口的包名一致 3.2、select 选择、查询语句； id就是对应的namespace中的方法名； resultType：sql语句执行的返回值！ parameterType：参数类型！ 1、编写接口 //获取全部用户 List<User> getUserList(); //根据id查询用户 User getUserById(int id); 2、编写对应的Mapper中
Mybatis中的@SelectKey注解
05-10 1596
一、创建Maven项目 在pom.xml中，添加mybatis依赖，mysql-jdbc依赖，把编译版本改为1.8 你问，为啥mybatis不会自动依赖mysql-jdbc，需要手动写明？答：因为mysql驱动是通过字符串动态加载的，这是一种“动态依赖”，Maven只能推导出“静态依赖”。“动态依赖”是一种更加灵活的依赖。 Maven默认的Java版本是1.6，无法使用lambda表达式...
MyBatis—利用MyBatis查询（查询所有，查询一行，条件查询）
热门推荐
chenxingxingxing的博客
03-16 2万+
MyBatis—利用MyBatis查询（查询所有，查询一行，条件查询）
mybatis笔记【狂神说】纯代码
qq_42839257的博客
02-28 578
Mybatis（持久层） 数据持久化 持久化就是程序的数据在持久状态和瞬时状态转换的过程 持久层 完成持久化工作的代码块，层界限十分明显 1、依赖 <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifa
通用mapper常用查询方法测试
iforeverhz的博客
05-29 4452
查询 List select(User record) User user = new User(); //条件 user.setName("hky"); user.setAge(22); //查询（参数是一个对象类型） List<User> users = userMapper.select(user); for (User user1 : users) { System.out.println(user1); } selectByPrimaryKey(O.
springboot+mybatis+navicat查询实现
04-25
好的，您需要查询实现Spring Boot和MyBatis结合使用的Navicat吗？在使用Spring Boot和MyBatis时，Navicat不能直接查询数据库。相反，您可以在MyBatis Mapper接口中定义SQL查询，并使用MapperScannerConfigurer将其与...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值