接着来说这个JSON循环引用的问题：
关于JSON格式的转化，其实关键就是这几个依赖：
<!-- json -->
<!-- 1号 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.8.1</version>
</dependency>
<!-- 2号 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.8.1</version>
</dependency>
<!-- 3号 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.8.1</version>
<exclusions>
<exclusion>
<artifactId>jackson-core</artifactId>
<groupId>com.fasterxml.jackson.core</groupId>
</exclusion>
<exclusion>
<artifactId>jackson-annotations</artifactId>
<groupId>com.fasterxml.jackson.core</groupId>
</exclusion>
</exclusions>
</dependency>
<!-- 4号 -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.7</version>
</dependency>
<!-- 5号 -->
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>
</dependency>
<!-- 5号json-lib还需要以下依赖包 -->
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.9.2</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
如果要解决查询出来实体 将实体转换为JSON数据的问题，Product产品类：Disease疾病类（1：n）这两个实体类正确写法如下：
Product.java
package com.agen.entity; import java.util.HashSet;
import java.util.Set; import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.Transient; import org.hibernate.annotations.GenericGenerator; import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.google.gson.annotations.Expose; /**
* Product entity. @author MyEclipse Persistence Tools
*/
@Entity
@Table(name = "product", catalog = "biologyinfo") public class Product implements java.io.Serializable { private static final long serialVersionUID = 1L;
private String productId;
private String productName;
private String productPath;
private Integer productOrder;
private String productCre;
private Set<Disease> diseases = new HashSet<Disease>(0); // Constructors /** default constructor */
public Product() {
} /** full constructor */
public Product(String productName, String productPath,
Integer productOrder, String productCre, Set<Disease> diseases) {
this.productName = productName;
this.productPath = productPath;
this.productOrder = productOrder;
this.productCre = productCre;
this.diseases = diseases;
} // Property accessors
@GenericGenerator(name = "generator", strategy = "uuid.hex")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "productId", unique = true, nullable = false, length = 36)
public String getProductId() {
return this.productId;
} public void setProductId(String productId) {
this.productId = productId;
} @Column(name = "productName", length = 30)
public String getProductName() {
return this.productName;
} public void setProductName(String productName) {
this.productName = productName;
} @Column(name = "productPath", length = 200)
public String getProductPath() {
return this.productPath;
} public void setProductPath(String productPath) {
this.productPath = productPath;
} @Column(name = "productOrder")
public Integer getProductOrder() {
return this.productOrder;
} public void setProductOrder(Integer productOrder) {
this.productOrder = productOrder;
} @Column(name = "productCre", length = 500)
public String getProductCre() {
return this.productCre;
} public void setProductCre(String productCre) {
this.productCre = productCre;
} @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "product")
public Set<Disease> getDiseases() {
return this.diseases;
} public void setDiseases(Set<Disease> diseases) {
this.diseases = diseases;
} }
Disease.java
package com.agen.entity; import java.util.HashSet;
import java.util.Set; import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table; import org.hibernate.annotations.GenericGenerator; import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.google.gson.annotations.Expose; /**
* Disease entity. @author MyEclipse Persistence Tools
*/
@Entity
@Table(name = "disease", catalog = "biologyinfo")
@JsonIgnoreProperties(value = {"product"})
public class Disease implements java.io.Serializable { /**
*
*/
private static final long serialVersionUID = 1L;
private String diseaseId;
private transient Product product;
private String diseaseName;
private String diseasePath;
private Integer diseaseOrder;
private String diseaseCre;
private Set<Filelist> filelists = new HashSet<Filelist>(0);
private Set<Gene> genes = new HashSet<Gene>(0); // Constructors /** default constructor */
public Disease() {
} /** minimal constructor */
public Disease(Product product) {
this.product = product;
} /** full constructor */
public Disease(Product product, String diseaseName, String diseasePath,
Integer diseaseOrder, String diseaseCre, Set<Filelist> filelists,
Set<Gene> genes) {
this.product = product;
this.diseaseName = diseaseName;
this.diseasePath = diseasePath;
this.diseaseOrder = diseaseOrder;
this.diseaseCre = diseaseCre;
this.filelists = filelists;
this.genes = genes;
} // Property accessors
@GenericGenerator(name = "generator", strategy = "uuid.hex")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "diseaseId", unique = true, nullable = false, length = 36)
public String getDiseaseId() {
return this.diseaseId;
} public void setDiseaseId(String diseaseId) {
this.diseaseId = diseaseId;
} @ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "productId", nullable = false)
public Product getProduct() {
return this.product;
} public void setProduct(Product product) {
this.product = product;
} @Column(name = "diseaseName", length = 30)
public String getDiseaseName() {
return this.diseaseName;
} public void setDiseaseName(String diseaseName) {
this.diseaseName = diseaseName;
} @Column(name = "diseasePath", length = 200)
public String getDiseasePath() {
return this.diseasePath;
} public void setDiseasePath(String diseasePath) {
this.diseasePath = diseasePath;
} @Column(name = "diseaseOrder")
public Integer getDiseaseOrder() {
return this.diseaseOrder;
} public void setDiseaseOrder(Integer diseaseOrder) {
this.diseaseOrder = diseaseOrder;
} @Column(name = "diseaseCre", length = 500)
public String getDiseaseCre() {
return this.diseaseCre;
} public void setDiseaseCre(String diseaseCre) {
this.diseaseCre = diseaseCre;
} @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "disease")
public Set<Filelist> getFilelists() {
return this.filelists;
} public void setFilelists(Set<Filelist> filelists) {
this.filelists = filelists;
} @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "disease")
public Set<Gene> getGenes() {
return this.genes;
} public void setGenes(Set<Gene> genes) {
this.genes = genes;
} }
第一种方法：
如上面的Disease.java实体类的类上添加了@JsonIgnoreProperties(value = {"product"})
这个表明 ，现在是在Disease对象的product字段上进行循环引用的隔断。
那么查询的时候，查询Product实体，其中的的disease这个字段是有值的；但是查询Disease实体，其中的product字段是没有值的，因为这个注解在Disease.java类上进行的注解。
同理，如果将这个注解加在哪个实体上，指定了哪个字段就是在哪个字段上阻断。
那么此时的Controller中，我要查询Product对象，并且要将查询出来的对象转化为JSON格式的数据：
@RequestMapping("/disease")
public String checkdisease(String productId, ModelMap model)
throws IOException {
Product product = productService.get(productId);
//将对象转化为JSON字符串
//方法1 com.fasterxml.jackson.databind.ObjectMapper 使用3号架包
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(product);
model.addAttribute("product", json);
//将JSON字符串 转化为对象[只是在此将方法列出，并无实际意义]
//com.fasterxml.jackson.databind.ObjectMapper 使用3号架包
Product product2 = mapper.readValue(json, Product.class);
return "/geneinfo/disease/disease";
}
第二种方法：
如上面的Disease.java实体类上添加了Java的关键字 transient
使用transient关键字的作用在于：变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问
这个也是阻断循环引用的一种方法。
同样的，查询Product实体，其中的的disease这个字段是有值的；但是查询Disease实体，其中的product字段是没有值的，因为这个关键字在Disease.java类的product字段上加的。
同理，将这个关键字加在那个字段上 就是在哪个字段上阻断。
那么 此时的Controller中，我们要查询Product对象，并且要将查询出来的对象转化为JSON格式的数据：
@RequestMapping("/disease")
public String checkdisease(String productId, ModelMap model)
throws IOException {
Product product = productService.get(productId);
//将对象转化为JSON字符串
//方法1 com.google.gson.Gson 使用4号架包
String json1 = new Gson().toJson(product);
model.addAttribute("product", json1);
return "/geneinfo/disease/disease";
}
声明：
上面的两种方法中 ，分别采用哪个架包中的哪个类，标识的很明白了。
但是由于Spring框架默认的是采用com.fasterxml.jackson.annotation进行JSON的转化，所以我们第一种方法中的@JsonIgnoreProperties(value = {"product"})注解必须要添加在实体上。
第二种中的transient关键字是和采用com.google.gson.Gson 谷歌提供的这个架包中的方法配套使用，如果不使用第二种方法进行对象转化JSON格式的数据，可以不用在字段上添加关键字。
声明2：
//net.sf.json.JSONObject
JSONObject.fromObject(product2).toString();
这种将Object转化为JSON数据的方法比较常见，但是它这个架包识别不到@JsonIgnoreProperties这个注解，因为他们不是同一个架包，不是同一个规范，所以在转化JSON的时候，会发生循环引用的问题。
因此这里不采用这种方式转化！！！
一个学习关键字transient的好文章 给大家推荐：http://www.cnblogs.com/lanxuezaipiao/p/3369962.html
当然使用了这两种的方法之后，就不用采用@JsonIgnore了。