Hibernate的映射组件属性
组件属性
如果持久化类的属性并不是基本数据类型，也不是一个日期或者字符串常量，而是一个复合类型的对象，例如 private Name name; 那么这就是一个组件属性。
组件属性可以是任何普通的java类对象，在映射文件中则用<compent>标签标识，<compent>中又可以像<class>那样包含<property>子元素，此外<compent>中还可以包含一个<parent>子元素用来指向容器实体。
下面演示组件属性的用法，比如在Person持久化类中有一个Name属性，
package com;
public class Person {
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Name getName() {
return name;
}
public void setName(Name name) {
this.name = name;
}
private Integer id;
private int age;
private Name name;
}
name属性的类型Name只是一个普通的java类，
package com;
public class Name {
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
public Person getOwner() {
return owner;
}
public void setOwner(Person owner) {
this.owner = owner;
}
private String first;
private String last;
private Person owner;
public Name() {
}
public Name(String first, String last) {
this.first = first;
this.last = last;
}
}
那么在person类的映射文件中，需要用<compent>表明name为一个组件属性，
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com">
<class name="Person" table="Person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="age" type="int" />
<component name="name" class="Name" unique="true">
<parent name="owner"/>
<property name="first" />
<property name="last" />
</component>
</class>
</hibernate-mapping>
下面写一个测试类，
package com; import java.util.HashMap;
import java.util.Map; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration; public class PersonManager {
public static void exec(String resource, Object obj) {
// 打开线程安全的session
Configuration conf = new Configuration().configure();
conf.addResource("com/"+resource);
// 用Configuration创建SessionFactory
SessionFactory sf = conf.buildSessionFactory();
// 用SessionFactory打开Session
Session sess = sf.openSession();
Transaction tx = sess.beginTransaction();
sess.save(obj);
tx.commit();
sess.close();
sf.close();
} public static void ComponentTest() {
Person cp = new Person();
cp.setAge(30);
Name name = new Name("天王盖地虎","宝塔镇河妖");
cp.setName(name);
exec("Person.hbm.xml",cp);
} public static void main(String[] args) {
ComponentTest();
}
}
执行程序，会发现hibernate生成的person_inf表中，hibernate将组件属性name映射成了person_inf表中的两个列，
组件属性为集合
如果组件属性是一个集合，例如list, map, set等， 那么可以在<compent>中包含<list> <set> <map>等子元素。
还是以上面的person为例，假如person的name属性中，多了一个power属性，power是map类型，
package com;
public class MapPerson {
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public MapName getName() {
return name;
}
public void setName(MapName name) {
this.name = name;
}
private Integer id;
private int age;
private MapName name;
}
package com; import java.util.HashMap;
import java.util.Map; public class MapName {
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
public Person getOwner() {
return owner;
}
public void setOwner(Person owner) {
this.owner = owner;
}
public MapName() { }
public MapName(String first, String last) {
this.first = first;
this.last = last;
} public Map<String, Integer> getPower() {
return power;
}
public void setPower(Map<String, Integer> power) {
this.power = power;
} private String first;
private String last;
private Person owner;
private Map<String, Integer> power = new HashMap<String, Integer>(); }
因此在person类的映射文件中，需要在<compent>标签里增加<map>子标签，
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com">
<class name="MapPerson" table="Person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="age" type="int" />
<component name="name" class="MapName" unique="true">
<parent name="owner"/>
<property name="first" />
<property name="last" />
<map name="power" table="name_power">
<key column="person_name_id" not-null="true" />
<map-key column="name_aspect" type="string" />
<element column="name_power" type="int"/>
</map>
</component>
</class>
</hibernate-mapping>
在测试类中新增测试方法mapTest()
public static void mapTest() {
MapPerson mp = new MapPerson();
mp.setAge(30);
MapName mn = new MapName("天王盖地虎","宝塔镇河妖");
Map<String, Integer> power = new HashMap<String, Integer>();
power.put("力量", 100);
power.put("速度", 90);
mn.setPower(power);
mp.setName(mn);
exec("MapPerson.hbm.xml",mp);
}
执行测试类，发现在mysql中，持久化类的属性为集合元素的时候，hibernate会将它映射成单独的一个表，并用外键关联持久化类。 其实这已经在映射文件中配置了。
person_inf表
name_power表
集合属性的元素为组件
这个跟前面的 “组件属性为集合”刚好反过来， 持久化类中的属性本身就是集合属性，在映射文件中依然用<list> <set> <map>等标签映射这些属性，不过对于这些属性中的值（集合元素），则用<composite-element>而不是<element>来映射。
还是以person类为例，假如person类中有个属性nicks，是map类型，
package com; import java.util.HashMap;
import java.util.Map; public class MapComPerson {
private Integer id;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Map<String, MapName> getNicks() {
return nicks;
}
public void setNicks(Map<String, MapName> nicks) {
this.nicks = nicks;
}
private int age;
private Map<String, MapName> nicks = new HashMap<String, MapName>();
}
此时的Name类已经不再是person的属性，而是构成person属性nicks中的map元素值类型，
package com; import java.util.HashMap;
import java.util.Map; public class MapName {
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
public Person getOwner() {
return owner;
}
public void setOwner(Person owner) {
this.owner = owner;
}
public MapName() { }
public MapName(String first, String last) {
this.first = first;
this.last = last;
} public Map<String, Integer> getPower() {
return power;
}
public void setPower(Map<String, Integer> power) {
this.power = power;
} private String first;
private String last;
private Person owner;
private Map<String, Integer> power = new HashMap<String, Integer>(); }
person类对应的映射文件，
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com">
<class name="MapComPerson" table="Person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="age" type="int" />
<map name="nicks" table="nick_inf">
<key column="person_id" not-null="true" />
<map-key column="phase" type="string" />
<composite-element class="MapName">
<parent name="owner" />
<property name="first" />
<property name="last" />
</composite-element>
</map>
</class>
</hibernate-mapping>
在测试类中新增mapComponentTest()方法，
public static void mapComponentTest() {
MapComPerson mcp = new MapComPerson();
mcp.setAge(25);
Map<String, MapName> nick = new HashMap<String, MapName>();
MapName mn = new MapName("天王盖地虎","宝塔镇河妖");
nick.put("小虎", mn);
mcp.setNicks(nick);
exec("MapComPerson.hbm.xml", mcp);
}
执行上面的测试类，发现在mysql中，当集合属性为组件的时候，Hibernate将集合属性放在单独表中，用外键关联主表，并将属性值映射成单独表中的列。
person_inf
nick_inf
组件作为map的索引(key)
对于集合类型，其key不仅可以是普通数据类型或者包装类型，例如String等，也可以是组件类型。Hibernate中使用<composite-map-key>来映射复合型的key。即每一个key又是另一种复合类的对象。这些复合类又会有自己的属性，
根据key复合类属性的类型，<composite-map-key>标签下又可以有两种子标签：
<key-property>，复合类属性为普通类型的数据，或者日期，字符串等。
<key-many-to-one>复合类属性引用了其他持久化类。
下面演示以组件作为map的索引，还是以person类为例，假如person类中有一个属性nickPower是map类型，其索引(key)的类型是Name，
package com; import java.util.HashMap;
import java.util.Map; public class MapKeyPerson {
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} public Map<MapKeyName, Integer> getNickPower() {
return nickPower;
}
public void setNickPower(Map<MapKeyName, Integer> nickPower) {
this.nickPower = nickPower;
} private Integer id;
private int age;
private Map<MapKeyName, Integer> nickPower = new HashMap<MapKeyName, Integer>();
}
这里的MapKeyName也只是一个普通的类，但是因为会作为Map集合的索引，所以必须以first和last这两个关键属性重写equals()和hashCode()两个方法，才能保证Map的正常工作
package com;
public class MapKeyName {
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
public Person getOwner() {
return owner;
}
public void setOwner(Person owner) {
this.owner = owner;
}
private String first;
private String last;
private Person owner;
public MapKeyName() {
}
public MapKeyName(String first, String last) {
this.first = first;
this.last = last;
}
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj != null && obj.getClass() == MapKeyName.class) {
MapKeyName target = (MapKeyName)obj;
if (target.getFirst().equals(getFirst())
&& target.getLast().equals(getLast())) {
return true;
}
}
return false;
}
public int hashCode() {
return getFirst().hashCode() * 13 + getLast().hashCode();
}
}
Person类的映射文件，
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com">
<class name="MapKeyPerson" table="person_inf">
<id name="id" column="person_id" type="int">
<generator class="identity" />
</id>
<property name="age" type="int" />
<map name="nickPower" table="nick_Power">
<key column="person_id" not-null="true" />
<!-- 因为may-key是复合类型，所以使用下面元素 -->
<composite-map-key class="MapKeyName">
<key-property name="first" type="string" />
<key-property name="last" type="string" />
</composite-map-key>
<element column="nick_power" type="int" />
</map>
</class>
</hibernate-mapping>
在测试类中新增测试方法mapKeyTest()，
public static void mapKeyTest() {
MapKeyPerson mkp = new MapKeyPerson();
mkp.setAge(25);
Map<MapKeyName, Integer> nickPower = new HashMap<MapKeyName, Integer>();
MapKeyName mkn = new MapKeyName();
mkn.setFirst("天王盖地虎");
mkn.setLast("宝塔镇河妖");
nickPower.put(mkn, 100);
mkp.setNickPower(nickPower);
exec("MapKeyPerson.hbm.xml", mkp);
}
执行上面的测试类，会发现Hibernate已经将MapKeyName组件的各种属性都映射到了集合属性表的各个列了，此时MapKeyName属性将作为map key使用，hibernate将外键列，MapKeyName各个属性一起作为联合主键。
person_inf
nick_power
nick_power表中的联合主键
组件作为复合主键
上面的持久化类的主键通常都是普通数据类型，如 private int id, 主键也可以是复合类型，即以组件作为主键。那么在映射文件中，就以<composite-id>来映射，在<composite-id>标签下以<key-property>来映射组件属性。
同时，因为主键将使用一个组件类型来代替，这个组件类型需要实现 java.io.Serializable 接口，
例如在下面的持久化类中，用复合类型的name作为主键，
package com;
public class PrimaryKeyPerson {
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public PrimaryKeyName getName() {
return name;
}
public void setName(PrimaryKeyName name) {
this.name = name;
}
private Integer id;
private int age;
private PrimaryKeyName name;
}
此复合类PrimaryKeyName也需要重写equals()和hashCode()方法（以first和last为关键属性），这个组件类型需要实现 java.io.Serializable 接口，
package com;
public class PrimaryKeyName implements java.io.Serializable {
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
private String first;
private String last;
public PrimaryKeyName() {}
public PrimaryKeyName(String first, String last) {
this.first = first;
this.last = last;
}
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj != null && obj.getClass() == PrimaryKeyName.class) {
PrimaryKeyName target = (PrimaryKeyName)obj;
return target.getFirst().equals(getFirst()) && target.getLast().equals(getLast());
}
return false;
}
public int hashCode() {
return this.getFirst().hashCode() * 7 + this.getLast().hashCode();
}
}
person类的映射文件如下，用<composite-id>映射复合组件为主键，用子元素<key-property>映射复合组件中的属性，
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com">
<class name="PrimaryKeyPerson" table="Person_inf">
<composite-id name="name" class="PrimaryKeyName">
<key-property name="first" type="string" />
<key-property name="last" type="string" />
</composite-id>
<property name="age" type="int" />
</class>
</hibernate-mapping>
在测试类中新增测试方法，PrimaryKeyTest()，
public static void PrimaryKeyTest() {
PrimaryKeyPerson pkp = new PrimaryKeyPerson();
PrimaryKeyName name = new PrimaryKeyName();
name.setFirst("天王盖地虎");
name.setLast("宝塔镇河妖");
pkp.setAge(20);
pkp.setName(name);
exec("PrimaryKeyPerson.hbm.xml", pkp);
}
执行上面的测试代码，发现Hibernate将PrimaryKeyName组件的所有属性映射为person类的列，成为person表的联合主键，
person_inf
person_inf表的联合主键。
多列作为联合主键
如果将持久化类中的多列作为联合主键，hibernate也用<composite-id>来映射，同时持久化类本身需要实现 java.io.Serializable接口，情形与上面的组件为复合主键非常类似，
假如person类中以first和last作为联合主键，首先要让person类实现 java.io.Serializable接口，并且重写equals和hashCode方法，
package com;
public class UnionKeyPerson implements java.io.Serializable {
private String first;
private String last;
private int age;
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj != null && obj.getClass() == PrimaryKeyName.class) {
PrimaryKeyName target = (PrimaryKeyName)obj;
return target.getFirst().equals(getFirst()) && target.getLast().equals(getLast());
}
return false;
}
public int hashCode() {
return this.getFirst().hashCode() * 7 + this.getLast().hashCode();
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
这种情况下就没有依赖的额外组件了，直接是持久化类和映射文件，映射文件如下，
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com">
<class name="UnionKeyPerson" table="Person_inf">
<composite-id>
<key-property name="first" type="string" />
<key-property name="last" type="string" />
</composite-id>
<property name="age" type="int" />
</class>
</hibernate-mapping>
映射文件也与前面的组件为联合主键非常类似，只不过这里的<composite-id>不需要额外映射组件类了，而是直接用持久化类中的属性，因此不再需要name和class标签了。
在测试类中新增UnionKeyTest()方法，
public static void UnionKeyTest() {
UnionKeyPerson ukp = new UnionKeyPerson();
ukp.setFirst("天王盖地虎");
ukp.setLast("宝塔镇河妖");
ukp.setAge(30);
exec("UnionKeyPerson.hbm.xml",ukp);
}
执行测试类，表结构与上面的完全相同，这里将以属性first和last作为联合主键，
使用JPA Annotation标注实体
在实际应用中，使用Annotation代替XML映射文件的情形更多，因为使用XML文件需要维护两个文件，而使用Annotation只需要维护一个文件。这些Annotation是JPA标准，与Hibernate无关，具体要求可以参考JavaEE规范的API。
如果将前面的person类改成Annotation方式来映射，将会是下面这样，
@Entity用来标注该类是一个持久化类，
@EmbeddedId用来标注复合类型的标识属性
@EmbeddedId用来标注组件属性
package com; import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.Table; @Entity
@Table(name="person_table")
public class AnnotationPerson {
@EmbeddedId
@AttributeOverrides({
@AttributeOverride(name="first", column=@Column(name="person_first")),
@AttributeOverride(name="last", column=@Column(name="person_last", length=20))
})
private AnnotationName name;
@Column(name="person_email")
private String email;
@Embedded
@AttributeOverrides({
@AttributeOverride(name="name", column=@Column(name="cat_name", length=35)),
@AttributeOverride(name="color", column=@Column(name="cat_color"))
})
private AnnotationCat pet;
public AnnotationName getName() {
return name;
}
public void setName(AnnotationName name) {
this.name = name;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public AnnotationCat getPet() {
return pet;
}
public void setPet(AnnotationCat pet) {
this.pet = pet;
}
}
上面持久化类中的name属性是一个组件属性，需要定义这个属性，在组件类名上面加上@Embeddable注解即可。
package com; import javax.persistence.Embeddable; @Embeddable
public class AnnotationName implements java.io.Serializable {
private String first;
private String last; public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
public AnnotationName() {}
public AnnotationName(String first, String last) {
this.first = first;
this.last = last;
}
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj != null && obj.getClass() == PrimaryKeyName.class) {
PrimaryKeyName target = (PrimaryKeyName)obj;
return target.getFirst().equals(getFirst()) && target.getLast().equals(getLast());
}
return false;
}
public int hashCode() {
return this.getFirst().hashCode() * 17 + this.getLast().hashCode();
} }
上面的pet也是一个属性组件，同样需要定义这个类，跟前面的name属性一样，
package com; import javax.persistence.Embeddable; @Embeddable
public class AnnotationCat {
public AnnotationCat() {}
public AnnotationCat(String name, String color) {
this.name = name;
this.color = color;
}
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
private String color;
}
有了上面这些持久化类和组件类之后即注解之后，就不再需要额外的映射文件了，在hibernate.cfg.xml中，
可以用<mapping class="xxxx/AnnotationPerson" />来加载持久化类，当然也可以直接在java代码中，用addAnnotatedClass()方法直接加载带注解的持久化类，
下面在测试类中新增测试方法annotationTest(),
public static void annotationTest() {
AnnotationPerson ap = new AnnotationPerson();
ap.setEmail("xxx@baidu.com");
AnnotationName name = new AnnotationName();
name.setFirst("天王盖地虎");
name.setLast("宝塔镇河妖");
ap.setName(name);
AnnotationCat pet = new AnnotationCat();
pet.setName("miaomiao");
pet.setColor("black");
ap.setPet(pet);
Configuration conf = new Configuration().configure();
conf.addAnnotatedClass(AnnotationPerson.class);
SessionFactory sf = conf.buildSessionFactory();
Session sess = sf.openSession();
Transaction tx = sess.beginTransaction();
sess.save(ap);
tx.commit();
sess.close();
sf.close();
}
执行测试类，可以看到hibernate将组件属性映射为表中的不同列了，并将name属性作为了联合主键，其效果跟用XML实现的映射文件完全一样。
person_table
person_table表结构
Hibernate的映射组件属性的更多相关文章
- Hibernate学习五----------组件属性
© 版权声明:本文为博主原创文章,转载请注明出处 实例 1.项目结构 2.pom.xml <project xmlns="http://maven.apache.org/POM/4.0 ...
- Hibernate映射Map属性2
Hibernate在映射Map属性时生成映射文件.需要注意的一些地方.下面是我的一个例子. Java类如下 public class NameAndNumber { private Integer i ...
- Hibernate之深入Hibernate的映射文件
这周周末 要把hibernate的映射文件搞定 .. 1.映射文件的主结构 主要结构 :根元素为<hibernate-mapping ></hibernate-mapping> ...
- hibernate课程 初探单表映射3-4 组件属性
本节内容: 1 简介组件属性 2 demo 1 简介组件属性: <component name = "address" class = "Address" ...
- Hibernate缓存、组件、继承映射
Hibernate缓存.组件.继承映射 三种状态: 临时状态:不受session管理,没有提交到数据库:没有执行sql之前,new对象的时候: 持久化状态:受session管理,提交到数据库:正在执行 ...
- 【学习笔记】Hibernate 一对一关联映射 组件映射 二级缓存 集合缓存
啊讲道理放假这十天不到啊 感觉生活中充满了绝望 这就又开学了 好吧好吧继续学习笔记?还是什么的 一对一关联映射 这次我们仍然准备了两个表 一个是用户表Users 一个是档案表Resume 他们的关系是 ...
- Hibernate映射集合属性
Hibernate要求持久化集合属性字段必须声明为接口,实际的接口可以是java.util.Set,java.util.Collection,java.util.List,java.util.Map, ...
- Hibernate映射Map属性
看到一篇Hibernate 映射Map属性的文章挺好的转载一下原地址:http://blog.sina.com.cn/s/blog_86f4502c0101fs1x.html Map集合属于有序集合, ...
- hibernate学习笔记（6）组件属性以及单表操作
组件属性:实体类中的某个属性属于用户自定义类的对象: 作用:将两个实体类合并在一起组建成一个表 在hbm.xml文件中配置: 格式: <component name="取的名字&quo ...
随机推荐
- [转载]ERP实施40问 60分钟外行变专家
http://www.chinaodoo.net/thread-389-1-1.html 在多年的实践中,结合自身经验和多年的理论积累,总结出有关ERP实施的最关键的40个问题,以问答的形式,让您在最 ...
- 自动化小应用系列----利用selenium启动多个独立的浏览器
在我们测试的时候对于同一个系统,我们往往需要登陆多个不同的账号,由于cookie的原因,我们只能退出一个账号在登陆另外一颗账号,非常麻烦.我们可以使用selenium来启动浏览器,这样每个浏览器的属性 ...
- 运用 Swing
一:Swing的组件: 组件(component,或称原件)就是你会放在GUI上的东西,这些东西用户可以看到并可以与之交互. 组件是可以嵌套的. 创建GUI的四个步骤: 1.创建window(JFra ...
- libgdx 裁剪多边形(clip polygon、masking polygon)
直接放例子代码,代码中以任意四边形为例,如果需要做任意多边形,注意libgdx不能直接用ShapeRender填充多边形,需要先切割成三角形. public static void drawClip( ...
- sublime 配置jade高亮显示
1.下载 Package Control.sublime-package 文件放入Packages文件目录下 2.control + shift + p 输入install package 3. ...
- 【leedcode】 Longest Palindromic Substring
Given a , and there exists one unique longest palindromic substring. https://leetcode.com/problems/l ...
- IntelliJ IDEA 12 与 Tomcat7 配置
IDEA 全称 IntelliJ IDEA,是java语言开发的集成环境,IntelliJ在业界被公认为最好的java开发工具之一,尤其在智能代码助手.代码自动提示.重构.J2EE支持.各类版本工具( ...
- C++之路进阶——codevs3566（紧急疏散）
3566 紧急疏散 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题目描述 Description 发生了火警,所有人员需要紧急疏散!假设每个房间是一 ...
- 【皇甫】☀ TreeSet
-Set: 元素是无序(存入和取出的顺序不一致),元素不可以重复 |-- HashSet: 底层数据结构是哈希表 HashSet是如何保证元素的唯一性的呢? 是通过元素的两个方法,hashCode和e ...
- nodejs require//////////z
背景 这篇文基本都是反对的,反对的很有道理,不是说我这篇文章的内容错误,因为这篇文章是我在健身房学习node的时候写的,这些知识都很粗糙,后来发现官方的稳定更详细:地址:http://nodejs.o ...