Mybatis输入输出映射_动态sql_关联关系(一对一、一对多、多对多)
Mybatis输入输出映射_动态sql_关联关系(一对一、一对多、多对多)
输入输出映射
parameterType完成输入映射
parameterType可以传入的参数有,基本数据类型(根据id查询用户的信息)、pojo类型(保存客户信息)、也可以传递pojo包装对象
可以定义pojo包装类型扩展mapper接口输入参数的内容。
需求:
自定义查询条件查询用户信息,需要向statement输入查询条件,查询条件user信息
编写包装数据类型
public class OrderUser extends Order {
// 自定义user的扩展信息
private String username;
private String address;
get/set方法
}
1
2
3
4
5
6
配置mapper.xml
<!-- 根据姓名进行模糊查询通过包装类型 -->
<!--
parameterType:使用别名
resultType:使用别名
-->
<select id="findUserByQureyVo" parameterType="queryVo" resultType="user">
SELECT
`id`,
`username`,
`birthday`,
`sex`,
`address`,
`uuid2`
FROM
USER
WHERE username like '%${user.username}%'
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
mapper.java Mapper接口
// 包装类型的测试(模糊查询)
public List<User> findUserByQureyVo(QueryVo vo) throws Exception;
1
2
测试:
private SqlSessionFactory sqlSessionFactory;
// 创建回话工厂
@Before
public void init() throws IOException {
// 1、Mybatis的核心配置文件
String resource = "SqlMapConfig.xml";
// 2、加载Mybatis的配置文件
InputStream is = Resources.getResourceAsStream(resource);
// 3、获取SqlSessionFactory对象,创建会话工厂,加载配置文件到输入 流
sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
}
@Test
/**
*
* @Title: testFindUserByQueryVo
* @Description: 模糊插叙用户信息
* @param
* @return void
*/
public void testFindUserByQueryVo() throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
// 根据接口得到实现类的代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
QueryVo queryVo = new QueryVo();
User user = new User();
user.setUsername("张");
queryVo.setUser(user);
List<User> list = userMapper.findUserByQureyVo(queryVo);
for (User user2 : list) {
System.out.println(user2);
}
sqlSession.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
resultType输出
返回的是pojo或者List<pojo>返回的类型都是pojo
返回简单数据类型
1、mapper.xml
<!-- 查询总记录数 -->
<select id="findUSerCount" resultType="int">
SELECT COUNT(*) FROM USER
</select>
1
2
3
4
2、配置接口:
// 查询记录总数
public Integer findUSerCount() throws Exception;
1
2
3、测试
public void testFindUserCount() throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
// 根据接口得到实现类的代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
Integer count = userMapper.findUSerCount();
System.out.println(count);
sqlSession.close();
}
1
2
3
4
5
6
7
8
返回pojo或者List<pojo>
1、mapper.xml
<!-- 模糊查询 -->
<select id="findUserByName" parameterType="String" resultType="user">
SELECT * FROM USER WHERE username like '%${value}%';
</select>
1
2
3
4
2、配置接口:
// 根据id查询用户的信息
public User findUserById(int id) throws Exception;
1
2
3、测试:
// 测试根据Id查询用户信息(得到单个数据)
@Test
public void findUserById() {
// 1、通过sqlSessionFactory创建sqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过sqlSession操作数据库
// 第一个参数:statement的位置,等于namespace+statement的id
// 第二个参数:传入的参数
User user = null;
try {
user = sqlSession.selectOne("user.findUserById", 16);
} catch (Exception e) {
e.printStackTrace();
} finally {
sqlSession.close();
}
System.out.println(user);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
resultMap输出
resultType(列名和属性名必须一致) :指定输出结果的类型(pojo、简单类型、hashmap…),将sql查询结果映射为java对象 (可以自定义)。
使用resultType注意:sql查询的列名要和resultType指定pojo的属性名相同,指定相同 属性方可映射成功,如果sql查询的列名要和resultType指定pojo的属性名全部不相同,list中无法创建pojo对象的。
resultMap(列名和属性名可以不一致使用映射完成):将sql查询结果映射为java对象。
如果sql查询列名和最终要映射的pojo的属性名不一致,使用resultMap将列名和pojo的属性名做一个对应关系 (列名和属性名映射配置)
需求: 查询出订单的所有信息
问题: Orders的pojo中属性字段和表中的orders的字段有不一致的(user_id和userId)
**分析:**此时我们就不可以简单的说过resultType类型进行返回值的接收,我们可以只用resultMap映射用于接收返回值
1、resultMap配置
<!-- 定义resultMap -->
<resultMap type="order" id="find_order_list">
<!-- 主键 -->
<id property="id" column="id" />
<!--
普通字段用<result>映射
property:pojo中的属性
column:表中对应的字段
-->
<result property="userId" column="user_id" />
<result property="number" column="number" />
<result property="createtime" column="createtime" />
<result property="note" column="note" />
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2、使用resultMap
<!--使用resultMap-->
<!--resultMap的值就是定义的resultMap中的id-->
<select id="findOrderListResultMap" resultMap="find_order_list">
SELECT
`id`,
`user_id`,
`number`,
`createtime`,
`note`
FROM
`order`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
3、编写接口:
// 使用resultMap
public List<Order> findOrderListResultMap() throws Exception;
1
2
总结resultType和resultMap
resultType:pojo中的 字段和表中 字段一致的,或者我们可以很方便的自己构建一个pojo类型并解决问题时使用resultType
resultMap: 字段和pojo字段不一致,表结构和关联关系比较复杂的
动态Sql
mybatis重点是对sql的灵活解析和处理。
将自定义查询条件查询用户列表和查询用户列表总记录数改为动态sql
根据传入不同的字段返回结果(名字或者性别查询)传入什么就根据什么进行查询
if和where
<!-- 动态Sql的if和where -->
<select id="findUserByPojo" parameterType="queryVo" resultType="user">
<include refid="user_sql"/>
<!-- <where>自动补上where关键字,同时处理多余and,用了where标签就不能再手动加上where关键字 -->
<where>
<!-- user.username表示从 QueryVo中的user属性取username属性-->
<if test="user.username != null and user.username != '' " >
and username like '%${user.username}%'
</if>
<if test="user.sex != null and user.sex != '' ">
and sex = #{user.sex}
</if>
<!-- 还有别的查询条件 -->
</where>
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
sql片段
通过sql片段可以将通用的sql语句抽取出来,单独定义,在其它的statement中可以引用sql片段。
通用的sql语句,常用:where条件、查询列
<!--
将用户查询条件定义为sq1片段建议对单表的查询条件单独抽取sq1片段,提高公用性
注意:不要将where标签放在sq1片段
-->
<sql id="user_sql">
SELECT
`id`,
`username`,
`birthday`,
`sex`,
`address`,
`uuid2`
FROM
USER
</sql>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
sql片段的引用
foreach的使用
在statement通过foreach遍历parameterType中的集合类型。
需求:根据多个用户id查询用户信息。
<!-- 动态Sql的foreach -->
<select id="findUserByIds" parameterType="queryVo" resultType="user">
<include refid="user_sql"/>
<where>
<!-- foreach的使用
id IN(1,22,26,35)
-->
<foreach collection="ids" open="id IN(" item="uid" separator="," close=")" >
#{uid}
</foreach>
</where>
</select>
1
2
3
4
5
6
7
8
9
10
11
12
关联关系
首先创建四张表,字段和关系如下图:
user表:
CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(32) NOT NULL COMMENT '用户名称',
`birthday` date DEFAULT NULL COMMENT '生日',
`sex` char(1) DEFAULT NULL COMMENT '性别',
`address` varchar(256) DEFAULT NULL COMMENT '地址',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
orders表:
CREATE TABLE `orders` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`user_id` int(11) NOT NULL COMMENT '下单用户id',
`number` varchar(32) NOT NULL COMMENT '订单号',
`createtime` datetime NOT NULL COMMENT '创建订单时间',
`note` varchar(100) DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`),
KEY `FK_orders_1` (`user_id`),
CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
9
10
orderdetail表:
CREATE TABLE `orderdetail` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`orders_id` int(11) NOT NULL COMMENT '订单id',
`items_id` int(11) NOT NULL COMMENT '商品id',
`items_num` int(11) DEFAULT NULL COMMENT '商品购买数量',
PRIMARY KEY (`id`),
KEY `FK_orderdetail_1` (`orders_id`),
KEY `FK_orderdetail_2` (`items_id`),
CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
9
10
11
items表:
CREATE TABLE `items` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) NOT NULL COMMENT '商品名称',
`price` float(10,1) NOT NULL COMMENT '商品定价',
`detail` text COMMENT '商品描述',
`pic` varchar(64) DEFAULT NULL COMMENT '商品图片',
`createtime` datetime NOT NULL COMMENT '生产日期',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
9
表关系
表关联关系
表分析
用户表user:
记录了购买商品的用户
订单表orders:
记录了用户所创建的订单信息
订单明细表orderdetail:
记录了用户创建订单的详细信息
商品信息表items:
记录了商家提供的商品信息
分析表与表之间的关系:
用户user和订单orders:
user---->orders:一个用户可以创建多个订单 一对多
orders–>user:一个订单只能由一个用户创建 一对一
订单orders和订单明细orderdetail:
orders–>orderdetail:一个订单可以包括多个订单明细 一对多
orderdetail–>orders:一个订单明细只属于一个订单 一对
订单明细orderdetail和商品信息items:
orderdetail–>items:一个订单明细对应一个商品信息 一对一
items–> orderdetail:一个商品对应多个订单明细 一对多
一、查询订单信息关联查询用户信息 一对一 resultType
sql语句的编写
-- 首先确定主表:user
-- 找到关联的从表:orders
-- 找出两者之间的关系 orders.`user_id`= user.`id`
SELECT
o.* ,
u.`username`,
u.`address`
FROM
orders o,
USER u
WHERE
o.`user_id`= u.`id`
1
2
3
4
5
6
7
8
9
10
11
12
使用resultType实现
首先实现基础的pojo
一对一查询映射的pojo:
创建pojo包括 订单信息和用户信息,resultType才可以完成映射。
创建OrderCustom作为自定义pojo,继承sql查询列多的po类。
public class OrderCustomer extends Orders {
//补充用户信息
private String username;
private String address;
}
1
2
3
4
5
6
定义mapper.xml文件
<!-- 一、查询订单信息关联查询用户信息 一对一 resultType -->
<select id="findOrderMapperCustomer" resultType="orderCustomer" >
SELECT
o.* ,
u.`username`,
u.`address`
FROM
orders o,
USER u
WHERE
o.`user_id`= u.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
mapper.java
// 一、查询订单信息关联查询用户信息 一对一 使用resultType
public List<OrderCustomer> findOrderMapperCustomer() throws Exception;
1
2
二、查询订单信息关联查询用户信息 一对一 使用resultMap
resultMap映射思路
resultMap提供一对一关联查询的映射和一对多关联查询映射,一对一映射思路:将关联查询的信息映射到pojo中,如下:
在Orders类中创建一个User属性,将关联查询的信息映射到User属性中。
sql语句的编写
SELECT
o.* ,
u.`username`,
u.`address`
FROM
orders o,
USER u
WHERE
o.`user_id`= u.`id`
1
2
3
4
5
6
7
8
9
定义resultMap
<!-- 二、查询订单信息关联查询用户信息 一对一 resultMap -->
<resultMap type="orders" id="order_mapper_customer">
<!-- 完成订单信息的映射配置 -->
<!-- id订单关联用户查询的唯一标识 -->
<id property="id" column="id" />
<result property="userId" column="user_id" />
<result property="number" column="number" />
<result property="createtime" column="createtime" />
<result property="note" column="note" />
<!-- 关联关系的信息映射
association:用于对关联信息映射到单个pojo
property:要将关联信息映射到orders的那个属性
javaType:关联信息映射到orders的属性的类型,是user类型
-->
<association property="user" javaType="com.syj.mybatis.pojo.User" >
<!-- id:关联信息的唯一标识 -->
<!-- property:要映射到user的那个属性中 -->
<id property="id" column="user_id" />
<!-- result:就是普通属性的列 -->
<result property="username" column="username" />
<result property="address" column="address" />
</association>
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
在mapper.xml使用定义的resultMap
<!-- 一对一查询使用resultMap完成订单关联查询用户的信息 -->
<select id="findOrderMapperCustomerResultMap" resultMap="order_mapper_customer">
SELECT
o.* ,
u.`username`,
u.`address`
FROM
orders o,
USER u
WHERE
o.`user_id`= u.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
编写mapper接口
// 二、查询订单信息关联查询用户信息 一对一 使用resultMap
public List<Orders> findOrderMapperCustomerResultMap() throws Exception;
1
2
小结
resultType:要自定义pojo 保证sql查询列和pojo的属性对应,这种方法相对较简单,所以应用广泛。
resultMap:使用association完成一对一映射需要配置一个resultMap,过程有点复杂,如果要实现延迟加载就只能用resultMap实现 ,如果为了方便对关联信息进行解析,也可以用association将关联信息映射到pojo中方便解析。
三、查询订单信息关联用户信息的订单详情 一对多 使用resultMap
sql语句的编写
SELECT
o.* ,
u.`username`,
u.`address`,
od.`orders_id` ordersid,
od.`items_id` itemsid,
od.`items_num` itemsnum
FROM
orders o,
USER u,
orderdetail od
WHERE
o.`user_id`= u.`id` AND od.`orders_id`= o.`id`
1
2
3
4
5
6
7
8
9
10
11
12
13
定义resultMap
<!--三、查询订单信息关联查询用户信息 一对多 resultMap -->
<resultMap type="orders" id="order_mapper_orderDetail" extends="order_mapper_customer">
<!-- 映射订单信息和用户信息,这里使用继承 order_mapper_customer -->
<!-- 映射订单明细
property :将要关联的信息映射到orders的那个属性
ofType :集合中Pojo的类型
-->
<collection property="orderdetails" ofType="Orderdetail">
<!-- 关联订单明细的唯一标识
property:Orderdetail的属性名
-->
<id property="id" column="ordersid" />
<result property="itemsId" column="itemsid" />
<result property="itemsNum" column="itemsnum" />
</collection>
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
在mapper.xml使用定义的resultMap
<select id="findOrderMapperOrderDetailResultMap" resultMap="order_mapper_orderDetail">
SELECT
o.* ,
u.`username`,
u.`address`,
od.`orders_id` ordersid,
od.`items_id` itemsid,
od.`items_num` itemsnum
FROM
orders o,
USER u,
orderdetail od
WHERE
o.`user_id`= u.`id` AND od.`orders_id`= o.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
编写mapper接口
// 三、查询订单信息关联用户信息的订单详情 一对多 使用resultMap
public List<Orders> findOrderMapperOrderDetailResultMap() throws Exception;
1
2
四、查询所有用户信息,关联查询订单及订单明细信息及商品信息,订单明细信息中关联查询商品信息
用户中包含订单,一个用户对应多个订单
订单中包含订单详情,一个订单详情对应多个订单详情
订单详情中包含商品,一个订单详情中包含一个商品
sql语句的编写
SELECT
u.*,
o.`id` order_id,
o.`number`,
o.`createtime`,
od.`id` orderdetail_id,
od.`items_id`,
od.`items_num`,
i.`name` ,
i.`detail`
FROM
`user` u,
orders o,
orderdetail od,
items i
WHERE u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
定义resultMap
<!-- 四、一对多的复杂查询
查询所有用户信息,关联查询订单及订单明细信息及商品信息,订单明细信息中关联查询商品信息
-->
<resultMap type="user" id="user_orders_ordersdetail_item">
<!-- 用户信息映射 -->
<!-- -->
<id property="id" column="id" />
<result property="username" column="username" />
<result property="sex" column="sex" />
<result property="birthday" column="birthday" />
<result property="address" column="address" />
<!-- 订单信息 -->
<collection property="orders" ofType="Orders" >
<id property="id" column="order_id" />
<result property="number" column="number" />
<result property="createtime" column="createtime" />
<!-- 订单明细 -->
<collection property="orderdetails" ofType="Orderdetail" >
<id property="id" column="orderdetail_id" />
<result property="itemsId" column="items_id" />
<result property="itemsNum" column="items_num" />
<!-- 商品信息 -->
<association property="items" javaType="Items" >
<id property="id" column="items_id" />
<result property="name" column="name" />
<result property="detail" column="detail" />
</association>
</collection>
</collection>
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
在mapper.xml使用定义的resultMap
<select id="findUserOrdersOrderDetailItem" resultMap="user_orders_ordersdetail_item">
SELECT
u.*,
o.`id` order_id,
o.`number`,
o.`createtime`,
od.`id` orderdetail_id,
od.`items_id`,
od.`items_num`,
i.`name` ,
i.`detail`
FROM
`user` u,
orders o,
orderdetail od,
items i
WHERE u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
编写mapper接口
// 四、查询所有用户信息,关联查询订单及订单明细信息及商品信息,订单明细信息中关联查询商品信息
public List<User> findUserOrdersOrderDetailItem() throws Exception;
1
2
练习一:用户账号、用户名称、用户性别、商品名称、商品价格(最常见)resultType类型
sql语句的编写
SELECT
u.`id`,
u.`username`,
u.`sex`,
i.`name`,
i.`price`
FROM
USER u,
orders o,
orderdetail od,
items i
WHERE u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
1
2
3
4
5
6
7
8
9
10
11
12
13
在mapper.xml使用
<!-- 练习一:用户账号、用户名称、用户性别、商品名称、商品价格(最常见)resultType类型 -->
<select id="findUserItem" resultType="UserItem">
SELECT
u.`id`,
u.`username`,
u.`sex`,
i.`name`,
i.`price`
FROM
USER u,
orders o,
orderdetail od,
items i
WHERE u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
编写mapper接口
// 练习一:用户账号、用户名称、用户性别、商品名称、商品价格(最常见)
public List<UserItem> findUserItem() throws Exception;
1
2
练习二:用户账号、用户名称、购买商品数量、商品明细
sql语句的编写
SELECT
u.`id`,
u.`username`,
od.`items_num` num,
i.`name`,
i.`price`,
i.`detail`,
i.`createtime`
FROM
USER u,
orders o,
orderdetail od,
items i
WHERE
u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
定义resultMap
<!-- 练习二:用户账号、用户名称、购买商品数量、商品明细 -->
<resultMap type="user" id="user_items">
<!-- 用户的映射配置 -->
<id property="id" column="id" />
<result property="username" column="username" />
<!-- 订单的配置 -->
<collection property="orders" ofType="Orders" >
<!-- 订单详情的映射 -->
<collection property="orderdetails" ofType="Orderdetail">
<result property="itemsNum" column="num" />
<!-- 商品的映射 -->
<association property="items" javaType="Items">
<result property="name" column="name" />
<result property="price" column="price" />
<result property="detail" column="detail" />
<result property="createtime" column="createtime" />
</association>
</collection>
</collection>
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
在mapper.xml使用定义的resultMap
<select id="findUserItems" resultMap="user_items" >
SELECT
u.`id`,
u.`username`,
od.`items_num` num,
i.`name`,
i.`price`,
i.`detail`,
i.`createtime`
FROM
USER u,
orders o,
orderdetail od,
items i
WHERE
u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
编写mapper接口
// 练习二:用户账号、用户名称、购买商品数量、商品明细(
public List<User> findUserItems() throws Exception;
1
2
resultMap:也是对查询结果集进行输出映射,根据自己需求可以通过resultMap将查询结果集映射到pojo中pojo属性中,还可以将多条记录结果集映射到pojo中List集合属性中。一对多、多对多、一对多这是针对业务来说的,可以写成符合一对一、一对多、多对多业务的sql语句,sql语句的结果集的映射由mybatis完成。写成一个复杂的多对多的sql语句,使用resultMap或resultType完成结果集映射。
---------------------
Mybatis输入输出映射_动态sql_关联关系(一对一、一对多、多对多)的更多相关文章
- MyBatis的关联关系 一对一 一对多 多对多
一对一示例 一个妻子对应一个丈夫 数据库表设计时 在妻子表中添加一个丈夫主键的作为外键 1 对应的JavaBean代码虽然在数据库里只有一方配置的外键,但是这个一对一是双向的关系. Husband实体 ...
- mybatis 一对一 一对多 多对多
一对一 一对多 多对多
- JPA级联(一对一 一对多 多对多)注解【实际项目中摘取的】并非自己实际应用
下面把项目中的用户类中有个:一对一 一对多 多对多的注解对应关系列取出来用于学习 说明:项目运行正常 问题类:一对多.一对一.多对多 ============一对多 一方的设置 @One ...
- Python进阶----表与表之间的关系(一对一,一对多,多对多),增删改查操作
Python进阶----表与表之间的关系(一对一,一对多,多对多),增删改查操作,单表查询,多表查询 一丶表与表之间的关系 背景: 由于如果只使用一张表存储所有的数据,就会操作数 ...
- MyBatis_[tp_48]_动态sql_内置参数_parameter&_databaseId
笔记要点-----内置参数_parameter&_databaseId 用处: 迅速切换数据库,执行一条多分支的sql语句即可;1.定义接口 public interface Emp ...
- 使用NHibernate(7)-- 一对一 && 一对多 && 多对多
1, 一对一. 对于数据量比较大的时候,考虑查询的性能,肯能会把一个对象的属性分到两个表中存放:比如用户和用户资料,经常使用的一般是Id和用户名,用户资料(学校,籍贯等)是不经常被查询的,所以就会分成 ...
- JPA 一对一 一对多 多对一 多对多配置
1 JPA概述 1.1 JPA是什么 JPA (Java Persistence API) Java持久化API.是一套Sun公司 Java官方制定的ORM 方案,是规范,是标准 ,sun公司自己并没 ...
- day 69-70 一对一 一对多 多对一联表查询
day 69 orm操作之表关系,多对多,多对一 多对一/一对多, 多对多{类中的定义方法} day69 1. 昨日内容回顾 1. 单表增删改查 2. 单表查询API 返回QuerySet对象的: 1 ...
- Mybatis中输入输出映射和动态Sql
一.输入映射 我们通过配置parameterType的值来指定输入参数的类型,这些类型可以是简单数据类型.POJO.HashMap等数据类型 1.简单类型 2.POJO包装类型 ①这是单表查询的时候传 ...
随机推荐
- Go实战--通过gin-gonic框架搭建restful api服务(github.com/gin-gonic/gin)
生命不止,继续 go go go !!! 先插播一条广告,给你坚持学习golang的理由: <2017 软件开发薪酬调查:Go 和 Scala 是最赚钱的语言> 言归正传! 之前写过使用g ...
- word2vec中的数学原理(转)
- 解决Linux主机上的 远程MySQL客户端无法连接的问题
无法连接到 MySQL 数据库可能的原因有: 1. PHP 无法连接 MySQL 可能是 PHP 配置不正确,没加上连接 MySQL 的功能. 2. MySQL 软件包升级,但没有升级数据库,或安装 ...
- bzoj 1613: [Usaco2008 Jan]Running贝茜的晨练计划【dp】
设f[i][j]为第i分钟疲劳j,从三种情况转移,记得休息的时候判断从i开始休息到n能不能恢复到疲劳0 #include<iostream> #include<cstdio> ...
- layui配置
layui是一个全局变量,可以在任何地方访问到 layui.config 方法主配置信息(经测试好像不能添加额外属性) layui.setter读取主配置属性 layui.extend 方法增加主配置 ...
- java启动参数二
非标准参数又称为扩展参数,其列表如下: -Xint 设置jvm以解释模式运行,所有的字节码将被直接执行,而不会编译成本地码. -Xbatch 关闭后台代码编译,强制在前台编译,编译完成之后才能进行代码 ...
- hdu 1044 Collect More Jewels
题意: 一个n*m的迷宫,在t时刻后就会坍塌,问:在逃出来的前提下,能带出来多少价值的宝藏. 其中: ’*‘:代表墙壁: '.':代表道路: '@':代表起始位置: '<':代表出口: 'A'~ ...
- 加密解密(1)HTTPS与HTTP区别
HTTPS简介 HTTPS(全称:Hypertext Transfer Protocol over Secure Socket Layer),是以安全为目标的HTTP通道,简单讲是HTTP的安全版.即 ...
- Android 线程池系列教程(5)与UI线程通信要用Handler
Communicating with the UI Thread 上一课 下一课 1.This lesson teaches you to Define a Handler on the UI Thr ...
- SimpleDateForma类
package Format_daqo; import java.text.SimpleDateFormat; import java.util.Date; public class SimpleDa ...