06_mybatis关系映射
1.数据库表分析
表与表之间的业务关系：
在分析表与表之间的业务关系时需要建立 在某个业务意义基础上去分析;
先分析数据级别之间有关系的表之间的业务关系;
usre和orders：
user---->orders：一个用户可以创建多个订单，一对多
orders—>user：一个订单只由一个用户创建，一对一
orders和orderdetail：
orders—>orderdetail：一个订单可以包括 多个订单明细，因为一个订单可以购买多个商品，每个商品的购买信息在orderdetail记录，一对多关系
orderdetail–> orders：一个订单明细只能包括在一个订单中，一对一
orderdetail和itesm：
orderdetail—>itesms：一个订单明细只对应一个商品信息，一对一
items–> orderdetail:一个商品可以包括在多个订单明细 ，一对多
再分析数据库级别没有关系的表之间是否有业务关系：
orders和items：
orders和items之间可以通过orderdetail表建立 关系。
2. 一对一查询
如：查询订单信息，关联查询创建订单的用户信息
2.1 resultType
2.1.1 sql语句
- 确定查询的主表：订单表
- 确定查询的关联表：用户表
- 关联查询使用内链接？还是外链接？
- 由于orders表中有一个外键（user_id），通过外键关联查询用户表只能查询出一条记录，可以使用内链接。
SELECT orders.*,USER.username,USER.sex,USER.address FROM orders,USER
WHERE orders.user_id = user.id
2.1.2 创建pojo
将上边sql查询的结果映射到pojo中，pojo中必须包括所有查询列名。原始的Orders.java不能映射全部字段，需要新创建的pojo。
创建 一个pojo继承包括查询字段较多的po类。
package com.mybatis.po;
/**
* Description:OrdersCustom 订单的扩展类，通过此类映射订单和用户查询的结果，让此类继承包括字段较多的pojo类
* User: jiatp
* Date:2019/9/4 0004 下午 4:29
*/
public class OrdersCustom extends Orders{
// 添加用户属性，username,sex,address
private String username;
private String sex;
private String address;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
2.1.3 mapper.xml
<!--查询 关联查询用户(一对一高级映射) 不使用resultMap-->
<select id="findOrdersUser" resultType="OrdersCustom">
SELECT
orders.*,
USER.username,
USER.sex,
USER.address
FROM
orders,
USER
WHERE
orders.user_id = USER.id
</select>
2.1.4 mapper.java
//查询订单的关联用户
public List<OrdersCustom> findOrdersUser()throws Exception;//使用resultType
2.2 resultMap
2.2.1 sql语句
SELECT orders.*,USER.username,USER.sex,USER.address FROM orders,USER
WHERE orders.user_id = user.id
2.2.2 Orders类中添加user属性
package com.mybatis.po;
import java.util.Date;
import java.util.List;
public class Orders {
private Integer id;
private Integer userId;
private String number;
private Date createtime;
private String note;
//用户信息
private User user;
//订单明细
private List<Orderdetail> Orderdetais;
public List<Orderdetail> getOrderdetais() {
return Orderdetais;
}
public void setOrderdetais(List<Orderdetail> orderdetais) {
Orderdetais = orderdetais;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number == null ? null : number.trim();
}
public Date getCreatetime() {
return createtime;
}
public void setCreatetime(Date createtime) {
this.createtime = createtime;
}
public String getNote() {
return note;
}
public void setNote(String note) {
this.note = note == null ? null : note.trim();
}
@Override
public String toString() {
return "Orders{" + "id=" + id + ", userId=" + userId + ", number='" + number + '\'' + ", createtime=" + createtime + ", note='" + note + '\'' + '}';
}
}
2.2.3 resultMap
使用resultMap将查询结果中的订单信息映射到Orders对象中，在orders类中添加User属性，将关联查询出来的用户信息映射到orders对象中的user属性中。
<!--查询 关联查询用户(一对一高级映射) 使用resultMap-->
<!--将查询结果映射到Orders中-->
<resultMap id="Orders_user" type="com.mybatis.po.Orders">
<!--配置映射的订单信息-->
<id column="id" property="id"></id>
<result column="user_id" property="userId"></result>
<result column="number" property="number"></result>
<result column="createtime" property="createtime"></result>
<result column="note" property="note"></result>
<!--配置关联的用户信息-->
<!--association:用于映射关联查询的对象信息
column：指定唯一标识用户的列
javaType：映射到user的某个属性
-->
<association property="user" javaType="com.mybatis.po.User">
<id column="user_id" property="id"></id>
<result column="username" property="username"></result>
<result column="address" property="address"></result>
<result column="sex" property="sex"></result>
</association>
</resultMap>
<select id="findOrdersUserResultMap" resultMap="Orders_user">
SELECT
orders.*,
USER.username,
USER.sex,
USER.address
FROM
orders,
USER
WHERE
orders.user_id = USER.id
</select>
2.2.4 mapper.java
package com.mybatis.test;
import com.mybatis.mapper.OrdersMapperCustom;
import com.mybatis.po.Orderdetail;
import com.mybatis.po.Orders;
import com.mybatis.po.OrdersCustom;
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 org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
/**
* Description:高级映射一对一
* User: jiatp
* Date:2019/9/4 0004 下午 4:56
*/
public class onetoone {
private SqlSessionFactory sqlSessionFactory;
@Before
public void setUp() throws IOException {
String resource = "com/mybatis/config/sqlMapConfig.xml";
InputStream resourceAsStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
}
//查询订单关联的用户信息（不使用resultMap）
@Test
public void testFindOrdersUser() throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
OrdersMapperCustom mapper = sqlSession.getMapper(OrdersMapperCustom.class);
List<OrdersCustom> list = mapper.findOrdersUser();
for(OrdersCustom ordersCustom:list) {
System.out.println(ordersCustom.getUsername());
}
sqlSession.close();
}
//查询订单关联的用户信息（使用resultMap）
@Test
public void testFindOrdersUserResultMap() throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
OrdersMapperCustom mapper = sqlSession.getMapper(OrdersMapperCustom.class);
List<Orders> list = mapper.findOrdersUserResultMap();
for(Orders orders:list) {
System.out.println(orders.getUser().getUsername());
}
sqlSession.close();
}
}
2.3 resultType和resultMap实现一对一查询小结
实现一对一查询：
resultType：使用resultType实现较为简单，如果pojo中没有包括查询出来的列名，需要增加列名对应的属性，即可完成映射。如果没有查询结果的特殊要求建议使用resultType。
resultMap：需要单独定义resultMap，实现有点麻烦，如果对查询结果有特殊的要求，使用resultMap可以完成将关联查询映射pojo的属性中。
resultMap可以实现延迟加载，无法实现延迟加载。
3. 一对多查询
如：查询订单及订单明细的信息。
3.1 sql语句
- 确定主查询表：订单表
- 确定关联查询表：订单明细表
- 在一对一查询基础上添加订单明细表关联即可。
SELECT
orders.*,
USER.username,
USER.sex,
USER.address,
orderdetail.id orderdetail_id,
orderdetail.items_id,
orderdetail.items_num,
orderdetail.orders_id
FROM
orders,
USER,
orderdetail
WHERE orders.user_id = user.id AND orderdetail.orders_id=orders.id
3.2 分析
当使用resultType将上边的 查询结果映射到pojo中，订单信息的就是重复
要求：
对orders映射不能出现重复记录。
在orders.java类中添加List orderDetails属性。
最终会将订单信息映射到orders中，订单所对应的订单明细映射到orders中的orderDetails属性中。
映射成的orders记录数为两条（orders信息不重复）
每个orders中的orderDetails属性存储了该 订单所对应的订单明细。
3.3 orders中添加list订单明细属性
package com.mybatis.po;
import java.util.Date;
import java.util.List;
public class Orders {
private Integer id;
private Integer userId;
private String number;
private Date createtime;
private String note;
//用户信息
private User user;
//订单明细
private List<Orderdetail> Orderdetais;
public List<Orderdetail> getOrderdetais() {
return Orderdetais;
}
public void setOrderdetais(List<Orderdetail> orderdetais) {
Orderdetais = orderdetais;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number == null ? null : number.trim();
}
public Date getCreatetime() {
return createtime;
}
public void setCreatetime(Date createtime) {
this.createtime = createtime;
}
public String getNote() {
return note;
}
public void setNote(String note) {
this.note = note == null ? null : note.trim();
}
@Override
public String toString() {
return "Orders{" + "id=" + id + ", userId=" + userId + ", number='" + number + '\'' + ", createtime=" + createtime + ", note='" + note + '\'' + '}';
}
}
3.4 mapper.xml
<!--查询订单,用户及订单明细的ResultMap-->
<resultMap id="findOrdersAndOrderDetailUserResultMap" type="com.mybatis.po.Orders" extends="Orders_user">
<!--订单信息-->
<!--用户信息-->
<!--可以使用继承实现-->
<!--订单明细信息-->
<!--一个订单查询对应多个订单明细，要使用collection进行映射
collection:对关联查询到多条记录映射到集合对象中
property:将关联查询的多条记录映射到order中Orderdetais属性
ofType:要映射集合属性中pojo的类型
-->
<collection property="Orderdetais" ofType="com.mybatis.po.Orderdetail" >
<!--id:订单明细的唯一标识-->
<id column="orderdetail_id" property="id"></id>
<result column="orderdetail.items_id" property="itemsId"></result>
<result column="orderdetail.items_num" property="itemsNum"></result>
<result column="orderdetail.orders_id" property="ordersId"></result>
</collection>
</resultMap>
<!--查询订单,用户及订单明细-->
<select id="findOrdersAndOrderDetailUserResultMap" resultMap="findOrdersAndOrderDetailUserResultMap">
SELECT
orders.*,
USER.username,
USER.sex,
USER.address,
orderdetail.id orderdetail_id,
orderdetail.items_id,
orderdetail.items_num,
orderdetail.orders_id
FROM
orders,
USER,
orderdetail
WHERE
orders.user_id = USER.id
AND orderdetail.orders_id = orders.id
</select>
3.5 mapper.java
//一对多 !--查询订单,用户及订单明细-->
public List<Orders> findOrdersAndOrderDetailUserResultMap()throws Exception;//使用resultMap
3.6 测试
package com.mybatis.test;
import com.mybatis.mapper.OrdersMapperCustom;
import com.mybatis.po.Orders;
import com.mybatis.po.OrdersCustom;
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 org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
/**
* Description:一对多查询
* User: jiatp
* Date:2019/9/4 0004 下午 5:34
*/
public class onetomany
{
private SqlSessionFactory sqlSessionFactory;
@Before
public void setUp() throws IOException {
String resource = "com/mybatis/config/sqlMapConfig.xml";
InputStream resourceAsStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
}
@Test
public void testfindOrdersAndOrderDetailUserResultMap() throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
OrdersMapperCustom mapper = sqlSession.getMapper(OrdersMapperCustom.class);
List<Orders> list = mapper.findOrdersAndOrderDetailUserResultMap();
for(Orders orders:list) {
System.out.println(orders);
}
sqlSession.close();
}
}
3.6 小结
mybatis使用resultMap的collection对关联查询的多条记录映射到一个list集合属性中。
使用resultType实现：
将订单明细映射到orders中的orderdetails中，需要自己处理，使用双重循环遍历，去掉重复记录，将订单明细放在orderdetails中。
4. 多对多查询
如：查询用户及用户购买商品信息。
4.1 sql语句
查询主表是：用户表
关联表：由于用户和商品没有直接关联，通过订单和订单明细进行关联，所以关联表：
orders、orderdetail、items
SELECT orders.*,USER.username, USER.sex,USER.address,orderdetail.id orderdetail_id,
orderdetail.items_id,orderdetail.items_num,orderdetail.orders_id,
items.name items_name,items.detail items_detail,items.price items_price
FROM orders,USER,orderdetail,items
WHERE orders.user_id = user.id AND orderdetail.orders_id=orders.id AND orderdetail.items_id = items.id
4.2 映射思路
- 将用户信息映射到user中。
- 在user类中添加订单列表属性List orderslist，将用户创建的订单映射到orderslist
- 在Orders中添加订单明细列表属性Listorderdetials，将订单的明细映射到orderdetials
- 在OrderDetail中添加Items属性，将订单明细所对应的商品映射到Items
4.3 pojo类
User.java
package com.mybatis.po;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
public class User implements Serializable {
private int id;
private String username;// 用户姓名
private String sex;// 性别
private Date birthday;// 生日
private String address;// 地址
private List<Orders> ordersList;
public List<Orders> getOrdersList() {
return ordersList;
}
public void setOrdersList(List<Orders> ordersList) {
this.ordersList = ordersList;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", sex=" + sex
+ ", birthday=" + birthday + ", address=" + address + "]";
}
}
Orders.java
package com.mybatis.po;
import java.util.Date;
import java.util.List;
public class Orders {
private Integer id;
private Integer userId;
private String number;
private Date createtime;
private String note;
//用户信息
private User user;
//订单明细
private List<Orderdetail> Orderdetais;
public List<Orderdetail> getOrderdetais() {
return Orderdetais;
}
public void setOrderdetais(List<Orderdetail> orderdetais) {
Orderdetais = orderdetais;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number == null ? null : number.trim();
}
public Date getCreatetime() {
return createtime;
}
public void setCreatetime(Date createtime) {
this.createtime = createtime;
}
public String getNote() {
return note;
}
public void setNote(String note) {
this.note = note == null ? null : note.trim();
}
@Override
public String toString() {
return "Orders{" + "id=" + id + ", userId=" + userId + ", number='" + number + '\'' + ", createtime=" + createtime + ", note='" + note + '\'' + '}';
}
}
Orderdetail.java
package com.mybatis.po;
public class Orderdetail {
private Integer id;
private Integer ordersId;
private Integer itemsId;
private Integer itemsNum;
//订单详情
private Items items;
public Items getItems() {
return items;
}
public void setItems(Items items) {
this.items = items;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getOrdersId() {
return ordersId;
}
public void setOrdersId(Integer ordersId) {
this.ordersId = ordersId;
}
public Integer getItemsId() {
return itemsId;
}
public void setItemsId(Integer itemsId) {
this.itemsId = itemsId;
}
public Integer getItemsNum() {
return itemsNum;
}
public void setItemsNum(Integer itemsNum) {
this.itemsNum = itemsNum;
}
@Override
public String toString() {
return "Orderdetail [id=" + id + ", ordersId=" + ordersId
+ ", itemsId=" + itemsId + ", itemsNum=" + itemsNum + "]";
}
}
4.4 mapper.xml
<resultMap id="findUsesAndItemsResultMap" type="com.mybatis.po.User">
<!--用户信息-->
<id column="user_id" property="id"></id>
<result column="username" property="username"></result>
<result column="address" property="address"></result>
<result column="sex" property="sex"></result>
<!--订单信息-->
<collection property="ordersList" ofType="com.mybatis.po.Orders" >
<!--id:订单明细的唯一标识-->
<id column="id" property="id"></id>
<result column="user_id" property="userId"></result>
<result column="number" property="number"></result>
<result column="createtime" property="createtime"></result>
<result column="note" property="note"></result>
<!--订单明细
一个订单对应多个订单明细
-->
<collection property="Orderdetais" ofType="com.mybatis.po.Orderdetail">
<!--id:订单明细的唯一标识-->
<id column="orderdetail_id" property="id"></id>
<result column="orderdetail.items_id" property="itemsId"></result>
<result column="orderdetail.items_num" property="itemsNum"></result>
<result column="orderdetail.orders_id" property="ordersId"></result>
<association property="items" javaType="com.mybatis.po.Items">
<!--id:商品的唯一标识-->
<id column="items_id" property="id"></id>
<result column="items_name" property="name"></result>
<result column="items_detail" property="detail"></result>
<result column="items_price" property="price"></result>
</association>
</collection>
</collection>
<!--可以使用继承实现-->
</resultMap>
<!--查询用户及用户购买商品信息-->
<select id="findUsesAndItemsResultMap" resultMap="findUsesAndItemsResultMap">
SELECT
orders.*,
USER.username,
USER.sex,
USER.address,
orderdetail.id orderdetail_id,
orderdetail.items_id,
orderdetail.items_num,
orderdetail.orders_id,
items.name items_name,
items.detail items_detail,
items.price items_price
FROM
orders,
USER,
orderdetail,
items
WHERE
orders.user_id = USER.id
AND orderdetail.orders_id = orders.id and orderdetail.items_id=items.id
</select>
<select id="findUserById" parameterType="int" resultType="user">
select * from user where id=#{id}
</select>
4.5 mapper.java
//多对多 查询用户及用户购买商品信息
public List<User> findUsesAndItemsResultMap();
4.6 多对多查询总结
将查询用户购买的商品信息明细清单，（用户名、用户地址、购买商品名称、购买商品时间、购买商品数量）
针对上边的需求就使用resultType将查询到的记录映射到一个扩展的pojo中，很简单实现明细清单的功能。
一对多是多对多的特例，如下需求：
查询用户购买的商品信息，用户和商品的关系是多对多关系。
需求1：
查询字段：用户账号、用户名称、用户性别、商品名称、商品价格(最常见)
企业开发中常见明细列表，用户购买商品明细列表，
使用resultType将上边查询列映射到pojo输出。
需求2：
查询字段：用户账号、用户名称、购买商品数量、商品明细（鼠标移上显示明细）
使用resultMap将用户购买的商品明细列表映射到user对象中。
总结：使用resultMap是针对那些对查询结果映射有特殊要求的功能，，比如特殊要求映射成list中包括 多个list。
5. resultMap总结
resultType：
作用：将查询结果按照sql列名pojo属性名一致性映射到pojo中。
场合：
常见一些明细记录的展示，比如用户购买商品明细，将关联查询信息全部展示在页面时，此时可直接使用resultType将每一条记录映射到pojo中，在前端页面遍历list（list中是pojo）即可。
resultMap：
使用association和collection完成一对一和一对多高级映射（对结果有特殊的映射要求）。
association：
作用：将关联查询信息映射到一个pojo对象中。
场合：
***为了方便查询关联信息可以使用association将关联订单信息映射为用户对象的pojo属性中，比如：查询订单及关联用户信息。****使用resultType无法将查询结果映射到pojo对象的pojo属性中，根据对结果集查询遍历的需要选择使用resultType还是resultMap。
collection：
作用：将关联查询信息映射到一个list集合中。
*场合：
为了方便查询遍历关联信息可以使用collection将关联信息映射到list集合中，比如：查询用户权限范围模块及模块下的菜单，可使用collection将模块映射到模块list中，将菜单列表映射到模块对象的菜单list属性中，这样的作的目的也是方便对查询结果集进行遍历查询。
如果使用resultType无法将查询结果映射到list集合中。
06_mybatis关系映射的更多相关文章
- 问题记录：EntityFramework 一对一关系映射
EntityFramework 一对一关系映射有很多种,比如主键作为关联,配置比较简单,示例代码: public class Teacher { public int Id { get; set; } ...
- 死去活来，而不变质：Domain Model（领域模型） 和 EntityFramework 如何正确进行对象关系映射？
写在前面 阅读目录: 设计误区 数据库已死 枚举映射 关联映射 后记 在上一篇<一缕阳光:DDD(领域驱动设计)应对具体业务场景,如何聚焦 Domain Model(领域模型)?>博文中, ...
- 解析大型.NET ERP系统数据访问 对象关系映射框架LLBL Gen Pro
LLBL Gen Pro是一个为.NET开发人员设计的的对象关系映射(ORM)框架,与NHibernate,Entity Framework等框架一样,通过实体与数据表的映射,实现关系数据库持久化. ...
- hibernate学习四（关系映射一对一与组件映射）
一.关系映射简介 在数据库中,表与表的关系,仅有外键.但使用hibernate后,为面向对象的编程,对象与对象的关系多样化:如 一对一,一对多,多对多,并具有单向和双向之分. 开始练习前,复制上一次项 ...
- Entity Framework Code First关系映射约定
本篇随笔目录: 1.外键列名默认约定 2.一对多关系 3.一对一关系 4.多对多关系 5.一对多自反关系 6.多对多自反关系 在关系数据库中,不同表之间往往不是全部都单独存在,而是相互存在关联的.两个 ...
- Mybatis框架中实现双向一对多关系映射
学习过Hibernate框架的伙伴们很容易就能简单的配置各种映射关系(Hibernate框架的映射关系在我的blogs中也有详细的讲解),但是在Mybatis框架中我们又如何去实现 一对多的关系映射呢 ...
- hibernate(3) —— 关系映射
hibernate中关系映射指的是实体类与实体类间的关系.和数据库中表与表之间的关系类似,有一对一,多对一,一对多,多对多四种映射关系. 一:一对一映射 两个对象之间是一对一的关系,如人和身份证之间是 ...
- OrchardNoCMS实体关系映射扩展
在OrchardNoCMS中,默认的系统会把实体关系映射保存到mappings.bin文件中. 如果不进行任何修改,默认的可以自动保存关系映射的model是有很大限制的. 条件是model的命名空间必 ...
- 【Java EE 学习 46】【Hibernate学习第三天】【多对多关系映射】
一.多对多关系概述 以学生和课程之间的关系为例. 1.在多对多关系中涉及到的表有三张,两张实体表,一张专门用于维护关系的表. 2.多对多关系中两个实体类中应当分别添加对方的Set集合的属性,并提供se ...
随机推荐
- Spring - @ManagedResource, @ManagedOperation, @ManagedAttribute
总结 通过annotation (@ManagedResource, @ManagedOperation, @ManagedAttribute)注解注册MBean到JMX实现监控java运行状态 参考 ...
- JUC 一 CountDownLatch（闭锁）
java.util.concurrent 介绍 CountDownLatch是一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待 CountDownLatch cou ...
- BOM的介绍
BOM的概念 BOM(Browser Object Model) 是指浏览器对象模型,浏览器对象模型提供了独立于内容的.可以与浏览器窗口进行互动的对象结构.BOM由多个对象组成,其中代表浏览器窗口的W ...
- Dart编程判断
条件/决策构造在执行指令之前评估条件. 下表是Dart中的条件语句 序号 声明和说明 1 if 语句 一个if语句由一个布尔表达式后跟一个或多个语句. 2 If...Else 语句 一个if可以跟一个 ...
- NX二次开发-UFUN创建倒圆UF_MODL_create_blend
NX9+VS2012 #include <uf.h> #include <uf_modl.h> UF_initialize(); //创建块 UF_FEATURE_SIGN S ...
- document.body / document.ducumentElement /等获取高度和宽度的区别
document.body / document.ducumentElement /等获取高度和宽度的区别 <!DOCTYPE html> <html> <head la ...
- c++ 枚举简单举例
#include <iostream> enum Enumeration{ VAL1, VAL2, VAL3=100, VAL4 }; int main() { using namespa ...
- LeetCode 1041. Robot Bounded In Circle (困于环中的机器人)
题目标签:Math 题目让我们判断机器人是否是一直在走一个圈. 当我们把 instructions 走完一遍时候: 1. 如果机器人回到了原点,那么它是在走一个圈. 2. 如果机器人的方向没有改变,那 ...
- hive简述
显示表头,当前终端有效 set hive.cli.print.header=true; 查看表结构 desc table; 详细的表结构 desc formatted table; 删除表 drop ...
- Memory barrier，
A memory barrier, also known as a membar, memory fence or fence instruction, 是一种屏障指令,它使中央处理单元(CPU)或编 ...