接着来说这个JSON循环引用的问题：
关于JSON格式的转化，其实关键就是这几个依赖：
1 <!-- json --> 2 3 <!-- 1号 --> 4 <dependency> 5 <groupId>com.fasterxml.jackson.core</groupId> 6 <artifactId>jackson-core</artifactId> 7 <version>2.8.1</version> 8 </dependency> 9 <!-- 2号 --> 10 <dependency> 11 <groupId>com.fasterxml.jackson.core</groupId> 12 <artifactId>jackson-annotations</artifactId> 13 <version>2.8.1</version> 14 </dependency> 15 16 <!-- 3号 --> 17 <dependency> 18 <groupId>com.fasterxml.jackson.core</groupId> 19 <artifactId>jackson-databind</artifactId> 20 <version>2.8.1</version> 21 <exclusions> 22 <exclusion> 23 <artifactId>jackson-core</artifactId> 24 <groupId>com.fasterxml.jackson.core</groupId> 25 </exclusion> 26 <exclusion> 27 <artifactId>jackson-annotations</artifactId> 28 <groupId>com.fasterxml.jackson.core</groupId> 29 </exclusion> 30 </exclusions> 31 </dependency> 32 33 <!-- 4号 --> 34 <dependency> 35 <groupId>com.google.code.gson</groupId> 36 <artifactId>gson</artifactId> 37 <version>2.7</version> 38 </dependency> 39 <!-- 5号 --> 40 <dependency> 41 <groupId>net.sf.json-lib</groupId> 42 <artifactId>json-lib</artifactId> 43 <version>2.4</version> 44 <classifier>jdk15</classifier> 45 </dependency> 46 <!-- 5号json-lib还需要以下依赖包 --> 47 <dependency> 48 <groupId>commons-lang</groupId> 49 <artifactId>commons-lang</artifactId> 50 <version>2.5</version> 51 </dependency> 52 <dependency> 53 <groupId>commons-beanutils</groupId> 54 <artifactId>commons-beanutils</artifactId> 55 <version>1.9.2</version> 56 </dependency> 57 <dependency> 58 <groupId>commons-collections</groupId> 59 <artifactId>commons-collections</artifactId> 60 <version>3.2.1</version> 61 </dependency> 62 <dependency> 63 <groupId>commons-logging</groupId> 64 <artifactId>commons-logging</artifactId> 65 <version>1.2</version> 66 </dependency>
如果要解决查询出来实体 将实体转换为JSON数据的问题，Product产品类：Disease疾病类（1：n）这两个实体类正确写法如下：
Product.java
1 package com.agen.entity; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 6 import javax.persistence.CascadeType; 7 import javax.persistence.Column; 8 import javax.persistence.Entity; 9 import javax.persistence.FetchType; 10 import javax.persistence.GeneratedValue; 11 import javax.persistence.Id; 12 import javax.persistence.OneToMany; 13 import javax.persistence.Table; 14 import javax.persistence.Transient; 15 16 import org.hibernate.annotations.GenericGenerator; 17 18 import com.fasterxml.jackson.annotation.JsonIgnore; 19 import com.fasterxml.jackson.annotation.JsonIgnoreProperties; 20 import com.google.gson.annotations.Expose; 21 22 /** 23 * Product entity. @author MyEclipse Persistence Tools 24 */ 25 @Entity 26 @Table(name = "product", catalog = "biologyinfo") 27 28 public class Product implements java.io.Serializable { 29 30 private static final long serialVersionUID = 1L; 31 private String productId; 32 private String productName; 33 private String productPath; 34 private Integer productOrder; 35 private String productCre; 36 private Set<Disease> diseases = new HashSet<Disease>(0); 37 38 // Constructors 39 40 /** default constructor */ 41 public Product() { 42 } 43 44 /** full constructor */ 45 public Product(String productName, String productPath, 46 Integer productOrder, String productCre, Set<Disease> diseases) { 47 this.productName = productName; 48 this.productPath = productPath; 49 this.productOrder = productOrder; 50 this.productCre = productCre; 51 this.diseases = diseases; 52 } 53 54 // Property accessors 55 @GenericGenerator(name = "generator", strategy = "uuid.hex") 56 @Id 57 @GeneratedValue(generator = "generator") 58 @Column(name = "productId", unique = true, nullable = false, length = 36) 59 public String getProductId() { 60 return this.productId; 61 } 62 63 public void setProductId(String productId) { 64 this.productId = productId; 65 } 66 67 @Column(name = "productName", length = 30) 68 public String getProductName() { 69 return this.productName; 70 } 71 72 public void setProductName(String productName) { 73 this.productName = productName; 74 } 75 76 @Column(name = "productPath", length = 200) 77 public String getProductPath() { 78 return this.productPath; 79 } 80 81 public void setProductPath(String productPath) { 82 this.productPath = productPath; 83 } 84 85 @Column(name = "productOrder") 86 public Integer getProductOrder() { 87 return this.productOrder; 88 } 89 90 public void setProductOrder(Integer productOrder) { 91 this.productOrder = productOrder; 92 } 93 94 @Column(name = "productCre", length = 500) 95 public String getProductCre() { 96 return this.productCre; 97 } 98 99 public void setProductCre(String productCre) { 100 this.productCre = productCre; 101 } 102 103 @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER, mappedBy = "product") 104 public Set<Disease> getDiseases() { 105 return this.diseases; 106 } 107 108 public void setDiseases(Set<Disease> diseases) { 109 this.diseases = diseases; 110 } 111 112 113 }
Disease.java
1 package com.agen.entity; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 6 import javax.persistence.CascadeType; 7 import javax.persistence.Column; 8 import javax.persistence.Entity; 9 import javax.persistence.FetchType; 10 import javax.persistence.GeneratedValue; 11 import javax.persistence.Id; 12 import javax.persistence.JoinColumn; 13 import javax.persistence.ManyToOne; 14 import javax.persistence.OneToMany; 15 import javax.persistence.Table; 16 17 import org.hibernate.annotations.GenericGenerator; 18 19 import com.fasterxml.jackson.annotation.JsonIgnore; 20 import com.fasterxml.jackson.annotation.JsonIgnoreProperties; 21 import com.google.gson.annotations.Expose; 22 23 /** 24 * Disease entity. @author MyEclipse Persistence Tools 25 */ 26 @Entity 27 @Table(name = "disease", catalog = "biologyinfo") 28 @JsonIgnoreProperties(value = {"product"}) 29 public class Disease implements java.io.Serializable { 30 31 32 /** 33 * 34 */ 35 private static final long serialVersionUID = 1L; 36 private String diseaseId; 37 private transient Product product; 38 private String diseaseName; 39 private String diseasePath; 40 private Integer diseaseOrder; 41 private String diseaseCre; 42 private Set<Filelist> filelists = new HashSet<Filelist>(0); 43 private Set<Gene> genes = new HashSet<Gene>(0); 44 45 // Constructors 46 47 /** default constructor */ 48 public Disease() { 49 } 50 51 /** minimal constructor */ 52 public Disease(Product product) { 53 this.product = product; 54 } 55 56 /** full constructor */ 57 public Disease(Product product, String diseaseName, String diseasePath, 58 Integer diseaseOrder, String diseaseCre, Set<Filelist> filelists, 59 Set<Gene> genes) { 60 this.product = product; 61 this.diseaseName = diseaseName; 62 this.diseasePath = diseasePath; 63 this.diseaseOrder = diseaseOrder; 64 this.diseaseCre = diseaseCre; 65 this.filelists = filelists; 66 this.genes = genes; 67 } 68 69 // Property accessors 70 @GenericGenerator(name = "generator", strategy = "uuid.hex") 71 @Id 72 @GeneratedValue(generator = "generator") 73 @Column(name = "diseaseId", unique = true, nullable = false, length = 36) 74 public String getDiseaseId() { 75 return this.diseaseId; 76 } 77 78 public void setDiseaseId(String diseaseId) { 79 this.diseaseId = diseaseId; 80 } 81 82 @ManyToOne(fetch = FetchType.LAZY) 83 @JoinColumn(name = "productId", nullable = false) 84 public Product getProduct() { 85 return this.product; 86 } 87 88 public void setProduct(Product product) { 89 this.product = product; 90 } 91 92 @Column(name = "diseaseName", length = 30) 93 public String getDiseaseName() { 94 return this.diseaseName; 95 } 96 97 public void setDiseaseName(String diseaseName) { 98 this.diseaseName = diseaseName; 99 } 100 101 @Column(name = "diseasePath", length = 200) 102 public String getDiseasePath() { 103 return this.diseasePath; 104 } 105 106 public void setDiseasePath(String diseasePath) { 107 this.diseasePath = diseasePath; 108 } 109 110 @Column(name = "diseaseOrder") 111 public Integer getDiseaseOrder() { 112 return this.diseaseOrder; 113 } 114 115 public void setDiseaseOrder(Integer diseaseOrder) { 116 this.diseaseOrder = diseaseOrder; 117 } 118 119 @Column(name = "diseaseCre", length = 500) 120 public String getDiseaseCre() { 121 return this.diseaseCre; 122 } 123 124 public void setDiseaseCre(String diseaseCre) { 125 this.diseaseCre = diseaseCre; 126 } 127 128 @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "disease") 129 public Set<Filelist> getFilelists() { 130 return this.filelists; 131 } 132 133 public void setFilelists(Set<Filelist> filelists) { 134 this.filelists = filelists; 135 } 136 137 @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "disease") 138 public Set<Gene> getGenes() { 139 return this.genes; 140 } 141 142 public void setGenes(Set<Gene> genes) { 143 this.genes = genes; 144 } 145 146 }
第一种方法：
如上面的Disease.java实体类的类上添加了@JsonIgnoreProperties(value = {"product"})
这个表明 ，现在是在Disease对象的product字段上进行循环引用的隔断。
那么查询的时候，查询Product实体，其中的的disease这个字段是有值的；但是查询Disease实体，其中的product字段是没有值的，因为这个注解在Disease.java类上进行的注解。
同理，如果将这个注解加在哪个实体上，指定了哪个字段就是在哪个字段上阻断。
那么此时的Controller中，我要查询Product对象，并且要将查询出来的对象转化为JSON格式的数据：
1 @RequestMapping("/disease") 2 public String checkdisease(String productId, ModelMap model) 3 throws IOException { 4 Product product = productService.get(productId); 5 //将对象转化为JSON字符串 6 //方法1 com.fasterxml.jackson.databind.ObjectMapper 使用3号架包 7 ObjectMapper mapper = new ObjectMapper(); 8 String json = mapper.writeValueAsString(product); 9 model.addAttribute("product", json); 10 11 //将JSON字符串 转化为对象[只是在此将方法列出，并无实际意义] 12 //com.fasterxml.jackson.databind.ObjectMapper 使用3号架包 13 Product product2 = mapper.readValue(json, Product.class); 14 15 return "/geneinfo/disease/disease"; 16 }
第二种方法：
如上面的Disease.java实体类上添加了Java的关键字 transient
使用transient关键字的作用在于：变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问
这个也是阻断循环引用的一种方法。
同样的，查询Product实体，其中的的disease这个字段是有值的；但是查询Disease实体，其中的product字段是没有值的，因为这个关键字在Disease.java类的product字段上加的。
同理，将这个关键字加在那个字段上 就是在哪个字段上阻断。
那么 此时的Controller中，我们要查询Product对象，并且要将查询出来的对象转化为JSON格式的数据：
1 @RequestMapping("/disease") 2 public String checkdisease(String productId, ModelMap model) 3 throws IOException { 4 Product product = productService.get(productId); 5 //将对象转化为JSON字符串 6 //方法1 com.google.gson.Gson 使用4号架包 7 String json1 = new Gson().toJson(product); 8 model.addAttribute("product", json1); 9 return "/geneinfo/disease/disease"; 10 }
声明：
上面的两种方法中 ，分别采用哪个架包中的哪个类，标识的很明白了。
但是由于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了。
