1、有泛型的类
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;
public class HttpClientObject<T> {
private Logger logger = Logger.getLogger(HttpClientObject.class);
private String url;
private T t;
public HttpClientObject() {
}
public void ts(Map<String,Integer> s){
}
/**
* HttpClient工具类
* @param url
* @param param:Map<String,String>
* @return
* @throws Exception
*/
public String post(String url,Map<String,String> param)throws Exception{
if(param.isEmpty() || StringUtils.isBlank(url))
throw new Exception("请求参数不合法");
Iterator<String> it = param.keySet().iterator();
List<NameValuePair> list = new ArrayList<NameValuePair>();
NameValuePair nv = null;
String key = "";
while(it.hasNext()){
key = it.next();
nv = new BasicNameValuePair(key,(String)param.get(key));
list.add(nv);
}
HttpClientObject<NameValuePair> client = new HttpClientObject<NameValuePair>();
client.setUrl(url);
String rsjson = client.doPost(list);
if(StringUtils.isBlank(rsjson))
throw new Exception("请求接口无结果 ，url = "+url);
return rsjson;
}
public String doPost(List<NameValuePair> list) {
String result = null;
try {
HttpEntity requesthttpEntity = new UrlEncodedFormEntity(list, "UTF-8");
HttpPost httpPost = new HttpPost(this.url);
httpPost.setEntity(requesthttpEntity);
HttpClient httpClient = new DefaultHttpClient();
httpClient.getParams().setParameter("http.connection.timeout", Integer.valueOf(20000));
httpClient.getParams().setParameter("http.socket.timeout", Integer.valueOf(20000));
this.logger.debug(httpPost.getURI());
StringBuffer sb = new StringBuffer();
for (NameValuePair p : list) {
sb.append("&" + p.getName() + "=" + p.getValue());
}
this.logger.debug("param=" + sb.toString());
HttpResponse httpResponse = httpClient.execute(httpPost);
if (httpResponse.getStatusLine().getStatusCode() != 200) {
throw new Exception("Failed : HTTP error code : " + httpResponse.getStatusLine().getStatusCode());
}
HttpEntity httpEntity = httpResponse.getEntity();
result = EntityUtils.toString(httpEntity);
}
catch (Exception e) {
logger.error("异常007"+e.getMessage());
}
return result;
}
/**
* @return the url
*/
public String getUrl() {
return url;
}
/**
* @return the t
*/
public T getT() {
return t;
}
/**
* @param url the url to set
*/
public void setUrl(String url) {
this.url = url;
}
/**
* @param t the t to set
*/
public void setT(T t) {
this.t = t;
}
}
2、无法泛型的类
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.xc.b2c.vo.Tree;
import com.xc.base.util.StringUtil;
public class CustomCommonUtil {
private static Log log = LogFactory.getLog(CustomCommonUtil.class);
public CustomCommonUtil() {
}
/**
* 保留Map中 keepKey对应数据，去掉其他的key-value
* @param mapList
* @param keepKey
*/
public static void filterMap(List<Map<String,String>> mapList,String ...keepKey ){
if(mapList != null){
List<String> keepKeyList = Arrays.asList(keepKey);
for(Map<String,String> map : mapList){
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
String key = (String) iterator.next();
//如果不是要保留的key,则romove掉
if (!keepKeyList.contains(key)) {
iterator.remove();
map.remove(key);
}
}
}
}
}
public static void filterMap(String value,List<Map<String,String>> mapList,String ...keepKey ){
if(mapList != null){
List<String> keepKeyList = Arrays.asList(keepKey);
for(Map<String,String> map : mapList){
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
String key = (String) iterator.next();
log.info("key is:"+key);
if(key.startsWith("imgUrl")){
map.put(key,value+map.get(key));
}
//如果不是要保留的key,则romove掉
if (!keepKeyList.contains(key)) {
iterator.remove();
map.remove(key);
}
}
}
}
}
/**
* 保留单个JSONObject中 keepKey对应数据，去掉其他的key-value
* @param jSONObject
* @param keepKey
*/
public static void filterJSONObject(JSONObject jSONObject,String ...keepKey ){
if(jSONObject != null){
List<String> keepKeyList = Arrays.asList(keepKey);
Iterator<String> iterator = jSONObject.keySet().iterator();
while (iterator.hasNext()) {
String key = (String) iterator.next();
//如果不是要保留的key,则romove掉
if (!keepKeyList.contains(key)) {
iterator.remove();
jSONObject.remove(key);
}
}
}
}
/**
* 深度 返回结果级过滤
* @param jSONObject
* @param keepNodes 不能为 null 否则会抛空指针异常
*/
public static void filterJSONObject(JSONObject jSONObject,List<Tree> keepNodes ){
//0、如果jSONObject 逻辑继续
if(jSONObject != null){
Iterator<String> iterator = jSONObject.keySet().iterator();
while (iterator.hasNext()) {
String key = (String) iterator.next();
//1、如果没有设置 保留的字段,当前的 jSONObject 数据全部不动
if(keepNodes==null) break;
//2、如果有配置 保留字段, 继续执行非保留字段去除工作
Tree subTree=TreeUtils.pickTreeByNodeName(keepNodes, key);
if (subTree==null) { //如果不是要保留的key,则romove掉
iterator.remove();
jSONObject.remove(key);
}else{
if(subTree.getNodeType()==ResultType.OBJECT){
Object subJsonObject = jSONObject.get(key); //是否JSON间传递的是引用,,,应该是引用后面的 原来的 filterJSONArray, 执行后得到的结果就是引用
if(subJsonObject instanceof JSONObject) //消除基本数据类型对处理的影响
CustomCommonUtil.filterJSONObject((JSONObject)subJsonObject, subTree.getSubTrees());
}else{
JSONArray subJsonArray = jSONObject.getJSONArray(key);
CustomCommonUtil.filterJSONArray(subJsonArray, subTree.getSubTrees());
}
}
}
}
}
/**
* 保留数组类型的中每个单个JSONObject中 keepKey对应数据，去掉其他的key-value
* @param jSONArray
* @param keepKey
*/
public static void filterJSONArray(JSONArray jSONArray,List<Tree> keepNodes ){
if(jSONArray != null){
for(int i=0; i<jSONArray.size(); i++){
JSONObject jSONObject = jSONArray.getJSONObject(i);
CustomCommonUtil.filterJSONObject(jSONObject, keepNodes);
}
}
}
/**
* 保留数组类型的中每个单个JSONObject中 keepKey对应数据，去掉其他的key-value
* @param jSONArray
* @param keepKey
*/
public static void filterJSONArray(JSONArray jSONArray,String ...keepKey ){
if(jSONArray != null){
for(int i=0; i<jSONArray.size(); i++){
JSONObject jSONObject = jSONArray.getJSONObject(i);
CustomCommonUtil.filterJSONObject(jSONObject, keepKey);
}
}
}
/***
* filter json string
*
* @param jsonStr
* @return
*/
public static JSONObject JsonFilter(JSONObject jsonStr, String... keepKey) {
JSONObject reagobj = jsonStr;
// 取出 jsonObject 中的字段的值的空格
Iterator itt = reagobj.keySet().iterator();
List<String> keepKeyList = Arrays.asList(keepKey);
while (itt.hasNext()) {
String key = itt.next().toString();
if (!keepKeyList.contains(key)) {
itt.remove();
reagobj.remove(key);
}
}
return reagobj;
}
/***
* 编码修改
* @param str
* @return
*/
public static String getChangeEncoded(String str) {
if (StringUtil.isEmpty(str)) {
return null;
} else {
try {
return new String(str.getBytes("iso-8859-1"), "UTF-8");
} catch (UnsupportedEncodingException e) {
log.error("ChangeEncoded错误", e);
return null;
}
}
}
/**
* get the class name
* @param clazz
* @return
*/
public static String getClassName(Class clazz) {
if (clazz != null) {
return clazz.getName();
}
return null;
}
/***
* 获取LeftFront45Picture 方法
*
* @param jSONArray
* @param name
* @return
*/
public static String getLeftFront45Picture(JSONArray jSONArray, String name) {
String target = "";
if (jSONArray != null) {
for (int i = 0; i < jSONArray.size(); i++) {
String orders = jSONArray.getString(i);
if (!StringUtils.isBlank(orders)) {
int lastIndexOf = orders.lastIndexOf("/");
if (name.equals(orders.substring(lastIndexOf + 1,
orders.length()))) {
target = orders;
break;
}
}
}
}
return target;
}
}
相关推荐
在Java编程语言中，继承是...总之，Java中的继承是非泛型类和泛型类共有的特性，允许子类获取并扩展父类的功能。在实际编程中，理解如何正确地继承和使用非泛型类是至关重要的，这有助于构建灵活且易于维护的代码结构。
2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip...
当我们谈论“继承泛型类”时，这意味着一个类（子类）正在扩展一个已经定义了泛型的类（父类）。这样，子类可以利用父类的泛型特性，并根据需要定制其类型约束。 首先，我们来理解一下泛型的基本概念。泛型引入的...
本示例将探讨如何在Java中实现泛型类的类型识别。 首先，我们来理解什么是类型识别（Runtime Type Information, RTTI）。在Java中，RTTI允许我们在程序运行时检查和操作对象的实际类型，这是通过使用`instanceof`...
泛型方法可以独立于类而独立存在，也可以在泛型类或非泛型类中定义。泛型方法的类型参数是方法特有的，与类的类型参数不同。 ### 泛型接口 泛型接口与泛型类类似，只不过它定义的是接口而不是类。泛型接口允许在...
- 泛型类是在定义类时声明一个或多个类型参数。例如，定义一个简单的泛型类`Box<T>`，其中`T`是类型参数。 ```java public class Box<T> { private T item; public void set(T item) { this.item = item; }...
类型参数是在定义类时使用的占位符，实际的类型在创建类的实例时指定。例如，我们可以创建一个名为`GenericContainer<T>`的泛型类，其中`T`就是类型参数。这个类可以存储任何类型的对象，但具体类型在实例化时确定。...
这意味着在运行时，泛型类和非泛型类没有区别，所有的类型参数都被替换为其边界类型（通常是 `Object`）。 6. **边界类型** - 类型参数可以指定边界，如 `List<? extends Number>`，表示 `T` 是 `Number` 或其子类...
本资源“Java源码泛型类的继承应用.rar”着重探讨了泛型类在继承结构中的运用，这对于我们理解如何在多层继承体系中管理和操作不同类型的数据具有重要意义。 首先，让我们来了解泛型类的基本概念。泛型类是在定义类...
Java泛型是Java编程语言中一个强大的特性，它允许在定义类、接口和方法时使用类型参数，从而实现参数化类型。泛型的主要目标是提高代码的类型安全性和重用性，减少类型转换的麻烦，并在编译时捕获可能的类型错误。...
在Java中，泛型工具类的构建对于实现通用功能、提高代码复用性和降低维护成本具有重要意义。 #### 核心知识点解析：泛型工具类 标题提到的“泛型工具类”主要指的是一种设计模式或编程实践，它提供了一系列用于...
泛型是一种抽象概念，它允许你在定义类、接口或方法时使用类型参数。这些类型参数在编译时会被具体的实际类型替换。如果你定义了一个类`MyClass<T>`，这里的`T`就是一个类型参数。当你创建`MyClass`的一个实例时，你...
泛型是Java语言中的一种参数化类型，它允许在定义类、接口和方法时使用类型参数，从而实现数据类型的模板化。通过泛型，我们可以创建可重复使用的组件，这些组件能在处理不同数据类型时保持一致的行为，同时确保编译...
参考：我眼中的Java-Type体系(1) 我眼中的Java-Type体系(2) 秒懂Java类型（Type）系统 Java 运行时如何获取泛型参数的类型 Java类型Type 之 ParameterizedType，GenericArrayType，TypeVariabl，WildcardType 从实现...
泛型是Java编程语言中用于减少类型转换错误和增强代码安全性的机制，它允许在定义类、接口和方法时使用类型参数。通过这种方式，可以在编译时期捕获那些只有在运行时期才会暴露的类型错误，提高了代码的健壮性。 ...
- 泛型是一种参数化类型，允许在定义类、接口和方法时使用类型参数，从而创建一种可以适用于多种类型的通用代码。 - 泛型的主要目标是提供类型安全，避免在运行时出现ClassCastException。 2. 泛型的声明与使用：...
泛型类允许我们在定义类时指定一个或多个类型参数。例如，我们可以定义一个简单的泛型类 `Box`： ```java public class Box<T> { private T item; public void setItem(T item) { this.item = item; } public...
7. **泛型和多态**：泛型类可以作为其他泛型类或非泛型类的参数，实现方法的多态性，比如`List<List<String>>`。 8. **限制性泛型**：通过泛型约束，可以限制类型参数必须遵循的规则，如`public class Box...