/**
* 实现的效果是：
* 同一个service.getProvider()方法
*
* Provider 使用request1参数来调用，得到的返回值是Provider
* Provider2使用request2参数来调用，得到的返回值是Provider2
*/
package a;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
/**
*
* @author bragel
*
*/
@XmlType
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "provider")
public class Provider {
@XmlElement(name = "provider_id")
private int id;
private Address address;
/**
* List会转化成一个item数组，item节点是network，包含items的节点是networks
*/
@XmlElementWrapper(name = "networks")
@XmlElement(name = "network")
private List<Network> networks;
@XmlElement(name = "is_primary_care_physician")
private boolean primaryCarePhysician;
/**
* 不会被输出
*/
@XmlTransient
private String remark;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public List<Network> getNetworks() {
return networks;
}
public void setNetworks(List<Network> networks) {
this.networks = networks;
}
public boolean isPrimaryCarePhysician() {
return primaryCarePhysician;
}
public void setPrimaryCarePhysician(boolean primaryCarePhysician) {
this.primaryCarePhysician = primaryCarePhysician;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String toString() {
return String.format("Provider:id:%s;address:%s;", id, address);
}
}
package a;
import java.util.List;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import javax.xml.bind.annotation.XmlType;
/**
*
* @author bragel
*
*/
@XmlType
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "provider")
public class Provider2 {
@XmlElement(name = "provider_id")
private int id;
@XmlElement(name = "address")
private Address2 address2 = new Address2();
/**
* List会转化成一个item数组，item节点是network，包含items的节点是networks
*/
@XmlElementWrapper(name = "networks")
@XmlElement(name = "network")
private List<Network> networks;
@XmlElement(name = "is_primary_care_physician")
private boolean primaryCarePhysician;
/**
* 不会被输出
*/
@XmlTransient
private String remark;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Address2 getAddress2() {
return address2;
}
public void setAddress2(Address2 address2) {
this.address2 = address2;
}
public List<Network> getNetworks() {
return networks;
}
public void setNetworks(List<Network> networks) {
this.networks = networks;
}
public boolean isPrimaryCarePhysician() {
return primaryCarePhysician;
}
public void setPrimaryCarePhysician(boolean primaryCarePhysician) {
this.primaryCarePhysician = primaryCarePhysician;
}
public String getRemark() {
return remark;
}
public void setRemark(String remark) {
this.remark = remark;
}
public String toString() {
return String.format("Provider2:id:%s;address:%s;", id, address2);
}
}
package a;
public class Request1 {
private int providerId;
private Integer networkId;
private double latitude;
private double longitude;
@Override
public String toString() {
return String.format("ProviderIdentifier{providerId=%d, networkId=%d, latitude=%s, longitude=%s}", providerId, networkId, latitude, longitude);
}
public Integer getNetworkId() {
return networkId;
}
public void setNetworkId(Integer networkId) {
this.networkId = networkId;
}
public double getLatitude() {
return latitude;
}
public void setLatitude(double latitude) {
this.latitude = latitude;
}
public double getLongitude() {
return longitude;
}
public void setLongitude(double longitude) {
this.longitude = longitude;
}
public int getProviderId() {
return providerId;
}
public void setProviderId(int providerId) {
this.providerId = providerId;
}
}
package a;
/*
* @author Brage
*/
public class Request2 {
private int providerId;
private int addressId;
@Override
public String toString() {
return String.format("ProviderIdentifier{providerId=%d, addressId=%d}", providerId, addressId);
}
public int getProviderId() {
return providerId;
}
public void setProviderId(int providerId) {
this.providerId = providerId;
}
public int getAddressId() {
return addressId;
}
public void setAddressId(int addressId) {
this.addressId = addressId;
}
}
package a;
/**
*
* @author bragel
*
*/
public class RequestCommon {
private int providerId;
private Integer networkId;
private double latitude = 0d;
private double longitude = 0d;
private int returnAddressId = 1;
private int addressId = 0;
public int getProviderId() {
return providerId;
}
public void setProviderId(int providerId) {
this.providerId = providerId;
}
public Integer getNetworkId() {
return networkId;
}
public void setNetworkId(Integer networkId) {
this.networkId = networkId;
}
public double getLatitude() {
return latitude;
}
public void setLatitude(double latitude) {
this.latitude = latitude;
}
public double getLongitude() {
return longitude;
}
public void setLongitude(double longitude) {
this.longitude = longitude;
}
public int getAddressId() {
return addressId;
}
public void setAddressId(int addressId) {
this.addressId = addressId;
}
public int getReturnAddressId() {
return returnAddressId;
}
public void setReturnAddressId(int returnAddressId) {
this.returnAddressId = returnAddressId;
}
}
Provider与Provider2的属性大部分是相同的，只是address不同，Provider的address里带经纬度，而Provider2里的address2没经纬度，address2的属性是address的属性的子集。
Request1里包含经纬度来查询Provider，
Request2里包含addressId来查询Provider2，
RequestCommon是Request1和Request2属性的全集。
我们先来看主要类，其他Address, Address2, Network等之后再贴出。
package a;
import java.util.Arrays;
/**
*
* @author bragel
*
*/
public class ProviderService {
/**
* 所有要使用到的泛型都必須在public/private等之後，返回類型void/String等之前用<>定義
* 如<T, V>
* 只是類型定義，不是返回類型，返回類型該是String或者T還是不能少
*
* @param clientId
* @param request
* @param t
* @return
* @throws Exception
*/
public <T, V> T getProvider(String clientId, V request, Class<T> t) throws Exception {
/**
* 1.request1, request2 -> RequestCommon(全集)
*/
RequestCommon common = V2Util.convert(request);
/**
* 2.用RequestCommon查询数据库，获得Provider(全集)
*/
Provider p = getProvider(common);
/**
* 3.Provider -> Provider2或者Provider?
*/
return V2Util.convert(p, t, common.getReturnAddressId());
}
/**
* 查询Provider
*
* @param request
* @return
*/
private Provider getProvider(RequestCommon request) {
Provider provider = new Provider();
provider.setId(1);
provider.setPrimaryCarePhysician(true);
provider.setRemark("hello");
Network n1 = new Network();
n1.setId(1);
n1.setCarrierGroupId(1);
n1.setCarrierIds(Arrays.asList(new Integer[] { 1, 2 }));
Network n2 = new Network();
n1.setId(2);
n1.setCarrierGroupId(1);
n1.setCarrierIds(Arrays.asList(new Integer[] { 1, 2, 3 }));
provider.setNetworks(Arrays.asList(new Network[] { n1, n2 }));
/**
* 根据这个returnAddressId，区分查询数据库
*/
if (request.getReturnAddressId() == 1) {
provider.setRemark("world");
}
Address address = new Address();
address.setId(1);
address.setCity("city");
address.setCounty("country");
address.setStreet("street");
address.setState("state");
address.setZip("zip");
provider.setAddress(address);
return provider;
}
}
package a;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.commons.beanutils.PropertyUtils;
/**
*
* @author bragel
*
*/
public class V2Util {
/**
* Request1 (providerId,networkId,latitude,longitude)
* Request2 (providerId,addressId)
* RequestCommon (providerId,networkId,latitude,longitude, returnAddressId,addressId)
* RequestCommon有以上两个类的所有属性（全集），并有returnAddressId来区分是哪一个类
*
* RequestCommon -> Request1或者Request2
*
* @param pi
* @param t
* @return
* @throws Exception
*/
public static <T> List<T> convert(List<RequestCommon> pi, Class<T> t) throws Exception {
List<T> cs = new ArrayList<T>();
for (RequestCommon p : pi) {
T c = t.newInstance();
PropertyUtils.copyProperties(c, p);
cs.add(c);
}
return cs;
}
/**
* ProviderIdentifier或者ProviderIdentifier2 -> ProviderIdentifierCommon
*
* @param pi
* @return
* @throws Exception
*/
public static <T> List<RequestCommon> convert(List<T> pi) throws Exception {
List<RequestCommon> cs = new ArrayList<RequestCommon>();
for (T p : pi) {
cs.add(convert(p));
}
return cs;
}
public static <T> RequestCommon convert(T p) throws Exception {
RequestCommon c = RequestCommon.class.newInstance();
PropertyUtils.copyProperties(c, p);
if (c.getAddressId() != 0) {
c.setReturnAddressId(0);
}
return c;
}
/**
* Provider -> Provider2, Provider?
* 注意Provider和Provider2的address不一样，
* Provider2的Address2有更多属性
* 既然Address和Address2是不同类型，所以它们在Provider和Provider2里就不能同名，1个叫address，1个叫address2
* 同名不同类型时，PropertyUtils.copyProperties(c, p);会报错
* 叫address2后，PropertyUtils.copyProperties(c, p);就不能给address2赋值，需要手动进行
*
* 在Provider2里给address2默认初始化private Address2 address2 = new Address2();,
* 也可手动赋值，PropertyUtils.setProperty(c, "address", new Address2());
* 然后再把Provider的address赋值给它，PropertyUtils.copyProperties(PropertyUtils.getProperty(c, "address2"), PropertyUtils.getProperty(p, "address"));
*
* @param p
* @param t
* @return
* @throws Exception
*/
public static <T> T convert(Provider p, Class<T> t, int returnAddressId) throws Exception {
T c = t.newInstance();
PropertyUtils.copyProperties(c, p);
if (returnAddressId == 0) {
PropertyUtils.copyProperties(PropertyUtils.getProperty(c, "address2"), PropertyUtils.getProperty(p, "address"));
}
return c;
}
}
package a;
import java.util.List;
/*
* @author bragel
*
*/
public class Test {
/**
* public <T, V> T getProvider(String clientId, V request, Class<T> t)
*
* 所有要使用到的泛型都必須在public/private等之後，返回類型void/String等之前用<>定義
* 如<T, V>
* <T, V>只是類型定義，不是返回類型，返回類型該是String或者T還是不能少
* @throws Exception
*
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ProviderService service = new ProviderService();
Request1 request1 = new Request1();
request1.setLatitude(0d);
request1.setLongitude(0d);
request1.setNetworkId(1);
request1.setProviderId(1);
Request2 request2 = new Request2();
request2.setProviderId(1);
request2.setAddressId(1);
/**
* 实现的效果是：
* 同一个service.getProvider()方法
*
* Provider 使用request1参数来调用，得到的返回值是Provider
* Provider2使用request2参数来调用，得到的返回值是Provider2
*/
Provider provider = service.getProvider("clientId", request1, Provider.class);
Provider2 provider2 = service.getProvider("clientId", request2, Provider2.class);
System.out.println(JaxbUtil.java2xml(provider, Provider.class));
System.out.println(JaxbUtil.java2xml(provider2, Provider2.class));
}
}
---------------------------------------------------------------------------------------
package a;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
/**
*
* @author bragel
*
*/
@XmlType
@XmlAccessorType(XmlAccessType.FIELD)
public class Address {
@XmlElement(name = "address_id")
private int id;
@XmlElement(name = "street")
private String street;
@XmlElement(name = "county")
private String county;
@XmlElement(name = "city")
private String city;
@XmlElement(name = "state")
private String state;
@XmlElement(name = "zip")
private String zip;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getCounty() {
return county;
}
public void setCounty(String county) {
this.county = county;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getZip() {
return zip;
}
public void setZip(String zip) {
this.zip = zip;
}
public String toString() {
return String.format("Address:id:%s;street:%s;country:%s;city:%s;state:%s;zip:%s;", id, street, county, city, state, zip);
}
}
package a;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
/**
*
* @author bragel
*
*/
@XmlType
@XmlAccessorType(XmlAccessType.FIELD)
public class Address2 {
@XmlElement(name = "address_id")
private int id;
@XmlElement(name = "street")
private String street;
@XmlElement(name = "county")
private String county;
@XmlElement(name = "city")
private String city;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getCounty() {
return county;
}
public void setCounty(String county) {
this.county = county;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String toString() {
return String.format("Address2:id:%s;street:%s;country:%s;city:%s;", id, street, county, city);
}
}
package a;
import javax.xml.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
@XmlType
@XmlAccessorType(XmlAccessType.FIELD)
public class Network {
@XmlElement(name = "network_id")
private int id;
@XmlElement(name = "name")
private String name;
@XmlElementWrapper(name = "carrierIds")
@XmlElement(name = "carrier_id")
private List<Integer> carrierIds = new ArrayList<Integer>();
@XmlTransient
private int carrierGroupId;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Integer> getCarrierIds() {
return carrierIds;
}
public void setCarrierIds(List<Integer> carrierIds) {
this.carrierIds = carrierIds;
}
public int getCarrierGroupId() {
return carrierGroupId;
}
public void setCarrierGroupId(int carrierGroupId) {
this.carrierGroupId = carrierGroupId;
}
}
package a;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.StringReader;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
public class JaxbUtil {
/**
* java -> xml String
*
*/
public static String java2xml(Object obj, Class beanClass) throws Exception {
JAXBContext context = JAXBContext.newInstance(beanClass);
// 根据上下文获取marshaller对象
Marshaller marshaller = context.createMarshaller();
// 设置编码字符集
marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
// 格式化XML输出，有分行和缩进
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
// 打印到控制台
//marshaller.marshal(obj, System.out);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
marshaller.marshal(obj, baos);
String xmlObj = new String(baos.toByteArray());
return xmlObj.replace(" standalone=\"yes\"", "");
}
/**
* java -> xml file
*
*/
public static void java2xmlFile(Object obj, Class beanClass, File file) throws Exception {
JAXBContext context = JAXBContext.newInstance(beanClass);
// 根据上下文获取marshaller对象
Marshaller marshaller = context.createMarshaller();
// 设置编码字符集
marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
// 格式化XML输出，有分行和缩进
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
// 打印到控制台
//marshaller.marshal(obj, System.out);
marshaller.marshal(obj, file);
}
/**
* xml -> java
*
*/
public static <T> T xml2java(String xml, Class<T> beanClass) throws Exception {
T bean = beanClass.newInstance();
JAXBContext context = JAXBContext.newInstance(beanClass);
Unmarshaller unmarshaller = context.createUnmarshaller();
bean = (T) unmarshaller.unmarshal(new StringReader(xml));
return bean;
}
/**
* xml file -> java
*
*/
public static <T> T xmlFile2java(File file, Class<T> beanClass) throws Exception {
T bean = beanClass.newInstance();
JAXBContext context = JAXBContext.newInstance(beanClass);
Unmarshaller unmarshaller = context.createUnmarshaller();
bean = (T) unmarshaller.unmarshal(file);
return bean;
}
}
因为Address2的属性是Address的子集，所以现在这样就可以了。
反之，如果Address2包含Address没有的属性，就需要跟Request一样，加一个AddressCommon了。
输出：
<?xml version="1.0" encoding="UTF-8"?>
<provider>
<provider_id>1</provider_id>
<address>
<address_id>1</address_id>
<street>street</street>
<county>country</county>
<city>city</city>
<state>state</state>
<zip>zip</zip>
</address>
<networks>
<network>
<network_id>2</network_id>
<carrierIds>
<carrier_id>1</carrier_id>
<carrier_id>2</carrier_id>
<carrier_id>3</carrier_id>
</carrierIds>
</network>
<network>
<network_id>0</network_id>
<carrierIds/>
</network>
</networks>
<is_primary_care_physician>true</is_primary_care_physician>
</provider>
<?xml version="1.0" encoding="UTF-8"?>
<provider>
<provider_id>1</provider_id>
<address>
<address_id>1</address_id>
<street>street</street>
<county>country</county>
<city>city</city>
</address>
<networks>
<network>
<network_id>2</network_id>
<carrierIds>
<carrier_id>1</carrier_id>
<carrier_id>2</carrier_id>
<carrier_id>3</carrier_id>
</carrierIds>
</network>
<network>
<network_id>0</network_id>
<carrierIds/>
</network>
</networks>
<is_primary_care_physician>true</is_primary_care_physician>
</provider>
相关推荐
深入理解java泛型，包括类名泛型的定义，方法泛型定义，泛型的返回
泛型类型：定义泛型类型时，使用尖括号<>，并在尖括号中指定类型参数。...例如，public static <T extends Comparable<T>> T max(T[] array)表示一个返回最大元素的泛型方法，且元素类型必须实现Comparable接口。
我们在使用动态数组实现 ArrayList 的时候，如果希望这个 ArrayList 不仅仅支持一个类型的话，我们可以给这个 ArrayList 定义泛型，泛型中存放的是T类型。在实际创建出这个 ArrayList 对象时，我们可以指定泛型中的...
24<br><br>0050 using关键字的用法 24<br><br>0051 变量的作用域 25<br><br>2.5 其他 26<br><br>0052 有效使用this对象 26<br><br>0053 如何声明变量 26<br><br>0054 如何声明相同类型的多个变量 26<br>...
【Flutter】Dart 泛型 ( 泛型类 | 泛型方法 | 特定类型约束的泛型 ) https://hanshuliang.blog.csdn.net/article/details/114059611 博客源码快照
C# 解析json格式数据为IList<T>
Json转换为实体;Json转换为IList<T>;实体转换为Json;IList<T>转换为Json;
泛型类vector<T>源码分析
在类的构造方法中，使用了一个类型参数T表示账户的余额类型，可以是Integer或Double。在deposit()和withdraw()方法中，根据传入的金额类型进行相应的计算，并返回结果。最后，通过调用getBalance()方法可以获取账户...
泛型类、泛型方法、泛型接口、泛型委托 泛型类、泛型方法、泛型接口、泛型委托
/// <param name="getAllAsync">1个具有返回值的泛型异步委托方法实例，该泛型异步委托方法实例用于获取1个指定实体的所有实例。</param> /// <param name="getCacheKey">1个具有返回值的委托方法实例，委托方法...
泛型List<T>中有一个比较列表是否已包含对象的方法Contains<T>()，今天在网上搜了一个用法，记录下来，备查。 要用此方法比较我们的自定义对象，首先要有一个比较器， 要注意的是，这里的比较器是实现...
WCF服务的操作方法中实现T GetEntity<T>(int id) where T: EntityBase
试用java.util.Stack<E>泛型栈作为父类，用另一个泛型栈对象作为成员变量，模拟实现一个泛型子类Queue<E>，当存储元素的第1个栈的元素超过dump时，再有元素入队列就倒入第2栈。除提供无参构造函数Queue( )外，其它...
下面小编就为大家带来一篇JAVA利用泛型返回类型不同的对象方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
泛型dao接口 ：GenericDao<T, ID extends Serializable> 泛型作为DAO的通用接口 CRUD方法 dao接口 : PersonDAO extends GenericDao<Person, Integer> 可以不写代码,方法已经在父类泛型dao里了,这里为了说明:可扩展...
主要介绍了Java泛型<T> T与T的使用方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是...
这是自己用在不使用泛型的基础上，用c++实现的一个vector功能，经过10万测试考验，没问题可用，如果大家有更好的建议和意见，还请指出，有不对的地方也请指出，大家一起进步，学习，加油。
java 泛型方法使用示例 java 泛型方法使用示例 java 泛型方法使用示例