勿忘初心1221
勿忘初心1221

springboot自定义注解使用AOP防止重复提交

这两天对防止重复提交做了一个回顾，发现之前博文中有很多都不全面，这里要说一声抱歉了，经过我重新整理一番，现重新发布。。。

【希望大家多多指正】

现附上我测试的demo地址：Github

 

对于重复提交问题，可能大多数人并没太注意，由于问题本身难被发现，导致人们的忽视。但这个问题一旦发生，就可能是致命的问题，特别是对于电商项目，或者金融类等会有致命性错误。

这两天在网上看了很多资料，，前端或者后端都有很好的实现方法，这里只总结了下后端处理方法。

这里我使用redis分布式锁，springAOP切面，自定义注解方式实现。

首先思路是：

  1. 在前端调接口时候，需要传token授权口令到后台接口；

  2. 接口在根据token和接口地址生成对应的key值，在通过UUID生成唯一value；

  3. 将key-value锁添加到redis缓存中并设置自定义的过期时间（如果能添加锁成功，则表示不是重复提交，否则为重复提交）

  4. 最后在接口执行完之后一定要释放锁哦。

现在启动你的redis，开始你的疯狂之旅吧。。。。。。

 

对于redis配置，以及pom文件，在这里直接粘贴出来：

#redis
spring.redis.open=true
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.timeout=6000ms
spring.redis.jedis.pool.max-active=8  
spring.redis.jedis.pool.max-wait=-1ms
spring.redis.jedis.pool.max-idle=8  
spring.redis.jedis.pool.min-idle=0

 


        1.8
        3.0.6
        1.2.10
        5.1.8
        2.2.6.RELEASE
        2.0.4.RELEASE
        1.3.0
        1.0.28
        8.0.11
    

    
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        

        
            com.baomidou
            mybatis-plus-boot-starter
            ${mybatis-plus-boot-starter}
        

        
        
            org.springframework.data
            spring-data-commons
            ${spring-data-commons.version}
        

        
            org.springframework.boot
            spring-boot-starter-data-jpa
            ${spring-boot-starter-data-jpa}
        

        
        
            com.github.pagehelper
            pagehelper-spring-boot-starter
            ${pagehelper-starter.version}
        
        
        
            com.github.pagehelper
            pagehelper
            ${pagehelper.version}
        


        
            ch.qos.logback
            logback-classic
            1.2.3
        

        
            org.projectlombok
            lombok
        

        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            ${mybatis.spring.boot.version}
        

        
        
            mysql
            mysql-connector-java
            ${mysql.version}
        
        
            com.alibaba
            druid
            ${druid.version}
        

        
            org.springframework.boot
            spring-boot-starter-aop
        
        
            org.springframework
            spring-context-support
        
        
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
            redis.clients
            jedis
        
        
            com.google.code.gson
            gson
            2.8.2
        

        
            org.apache.commons
            commons-pool2
        

        
        
            org.springframework.boot
            spring-boot-starter-data-redis
            
                
                    redis.clients
                    jedis
                
                
                    io.lettuce
                    lettuce-core
                
            
        
        
            com.alibaba
            fastjson
            1.2.45
        
        
            log4j
            log4j
            1.2.17
        

        
        
            org.slf4j
            slf4j-api
            1.7.25
        
        
        
            org.slf4j
            slf4j-log4j12
            1.7.25

1.首先自定义不重复提交注解NoRepeatSubmit

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 防止重复提交自定义注解
 * @author zhang
 *
 */
@Target(ElementType.METHOD) // 说明了Annotation所修饰的对象范围
@Retention(RetentionPolicy.RUNTIME) // 用于描述注解的生命周期（即：被描述的注解在什么范围内有效）
@Documented // 是一个标记注解，没有成员 （文档化）
public @interface NoRepeatSubmit {

	/**
     * 设置请求锁定时间
     *
     * @return
     */
    int lockTime() default 10;
	
}

2.第二就是切面处理RepeatSubmitAspect

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;

import com.zhang.common.annotation.NoRepeatSubmit;
import com.zhang.common.utils.R1;
import com.zhang.common.utils.RedisUtils;
import com.zhang.common.utils.RequestUtils;

import javax.servlet.http.HttpServletRequest;

import java.lang.reflect.Method;
import java.util.UUID;


/**
 * 防止重复提交处理
 * @author zhang
 *
 */
@Aspect
@Component
public class RepeatSubmitAspect {

	private static final Logger LOGGER = LoggerFactory.getLogger(RepeatSubmitAspect.class);

    @Autowired
    private RedisUtils redisUtils;

    @Pointcut("@annotation(noRepeatSubmit)")
    public void pointCut(NoRepeatSubmit noRepeatSubmit) {
    }

    @Around("pointCut(noRepeatSubmit)")
    public Object around(ProceedingJoinPoint pjp, NoRepeatSubmit noRepeatSubmit) throws Throwable {
        int lockSeconds = noRepeatSubmit.lockTime();
        String threadName = Thread.currentThread().getName();// 获取当前线程名称
        HttpServletRequest request = RequestUtils.getRequest();
        Assert.notNull(request, "request can not null");

        String token = request.getHeader("Authorization");// 前端调后台接口传 登录时已获取到的授权口令Authorization
        String path = request.getServletPath();// 前端调接口地址
        LOGGER.info("token；当前请求线程名称threadName；path:, token = [{}], threadName = [{}] , path = [{}]", token, threadName, path);
        
        String key = getKey(token, path);// 调接口时生成临时key
        String clientId = getClientId();// 调接口时生成临时value

        
        // 此处为自测通过ProceedingJoinPoint获取当前请求的方法名称
        // 方法一
        Signature signature = pjp.getSignature();
        MethodSignature ms = (MethodSignature)signature;
        Method method = ms.getMethod();
        LOGGER.info("获取方法一, method = [{}]", method);
        // 方法二
        Signature sig = pjp.getSignature();
		MethodSignature msig = null;
		if (!(sig instanceof MethodSignature)) {
			throw new IllegalArgumentException("该注解只能用于方法");
		}
		msig = (MethodSignature) sig;
		Object target = pjp.getTarget();
		Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
		LOGGER.info("获取方法二, currentMethod = [{}]", currentMethod);
		
		
        boolean isSuccess = redisUtils.tryLock(key, clientId, lockSeconds);// 用于添加锁，如果添加成功返回true，失败返回false
        LOGGER.info("tryLock 当前请求线程名称threadName, threadName = [{}], key = [{}], clientId = [{}]", threadName, key, clientId);
        
        if (isSuccess) {
            LOGGER.info("tryLock success 线程名称threadName：, threadName = [{}], key = [{}], clientId = [{}]",threadName, key, clientId);
            // 获取锁成功
            Object result;

            try {
                // 执行进程
                result = pjp.proceed();// aop代理链执行的方法
            } finally {
            	// 据key从redis中获取value
            	String value = redisUtils.get(key);
        		LOGGER.info("releaseLock start when 'value = clientId', key = [{}], value = [{}], clientId = [{}]", key, value, clientId);
        		if (clientId.equals(redisUtils.get(key))) {
            		LOGGER.info("releaseLock start, key = [{}], value = [{}], clientId = [{}]", key, value, clientId);
            		// 解锁
                	redisUtils.releaseLock(key, clientId);
                	LOGGER.info("releaseLock success 线程名称threadName：, threadName = [{}], key = [{}], clientId = [{}]",threadName, key, clientId);
				}
            }
            return result;
        } else {
            // 添加锁失败，认为是重复提交的请求
        	LOGGER.info("重复请求，请稍后再试    线程名称threadName：" + threadName);
        	LOGGER.info("tryLock fail 线程名称threadName：, threadName = [{}], key = [{}]",threadName, key);
            return R1.error(403, "重复请求，请稍后再试");
        }

    }

    private String getKey(String token, String path) {
        return token + path;
    }

    private String getClientId() {
        return UUID.randomUUID().toString();
    }

}

3.第三是redis工具类和RequestUtils工具类以及接口统一返回格式R1工具类

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;

import java.util.Collections;
import java.util.concurrent.TimeUnit;

/**
 * Redis 工具类
 * @author zhang
 * @date 2020-04-24 10:28:40
 */
@Component
public class RedisUtils {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final Long RELEASE_SUCCESS = 1L;
    //    private static final String LOCK_SUCCESS = "OK";
    private static final Long LOCK_SUCCESS1 = 1L;
    private static final String SET_IF_NOT_EXIST = "NX";
    /** 设置过期时间单位, EX = seconds; PX = milliseconds */
    private static final String SET_WITH_EXPIRE_TIME = "EX";
    // if get(key) == value return del(key)
    private static final String RELEASE_LOCK_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    /**  不设置过期时长 */
    public final static long NOT_EXPIRE = -1;
    /**  默认过期时长，单位：秒 */
    public final static long DEFAULT_EXPIRE = 60 * 60 * 24;

    Gson gson = new Gson();

    public void set(String key, Object value, long expire){
        stringRedisTemplate.opsForValue().set(key, toJson(value));
        if(expire != NOT_EXPIRE){
            stringRedisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
    }

    public void set(String key, Object value){
        set(key, value, DEFAULT_EXPIRE);
    }

    public  T get(String key, Class clazz, long expire) {
        String value = stringRedisTemplate.opsForValue().get(key);
        if(expire != NOT_EXPIRE){
            stringRedisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value == null ? null : fromJson(value, clazz);
    }

    public  T get(String key, Class clazz) {
        return get(key, clazz, NOT_EXPIRE);
    }

    public String get(String key, long expire) {
        String value = stringRedisTemplate.opsForValue().get(key);
        if(expire != NOT_EXPIRE){
            stringRedisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return value;
    }

    public String get(String key) {
        return get(key, NOT_EXPIRE);
    }

    public void delete(String key) {
        stringRedisTemplate.delete(key);
    }


    /**
     * 该加锁方法仅针对单实例 Redis 可实现分布式加锁
     * 对于 Redis 集群则无法使用
     *
     * 支持重复，线程安全
     *
     * @param lockKey   加锁键
     * @param clientId  加锁客户端唯一标识(采用UUID)
     * @param seconds   锁过期时间
     * @return
     */
    public boolean tryLock(String lockKey, String clientId, int seconds) {
        return stringRedisTemplate.execute((RedisCallback) redisConnection -> {
            Jedis jedis = (Jedis) redisConnection.getNativeConnection();
            //此方法报错，查看源码jedis.set方法不能如此传参
//            String result = jedis.set(lockKey, clientId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, seconds);

//            SetParams setParams = new SetParams();// 设置key的过期时间单位
//            setParams.px(seconds); // （EX = seconds; PX = milliseconds）
//            String result = jedis.set(lockKey, clientId, setParams);

            long result = jedis.setnx(lockKey, clientId);// jedis.setnx该方式赋值（成功返回1，否则返回0）
            if (LOCK_SUCCESS1 == result) {
                return true;
            }

            return false;
        });
    }

    /**
     * 与 tryLock 相对应，用作释放锁
     *
     * @param lockKey
     * @param clientId
     * @return
     */
    public boolean releaseLock(String lockKey, String clientId) {
        return stringRedisTemplate.execute((RedisCallback) redisConnection -> {
            Jedis jedis = (Jedis) redisConnection.getNativeConnection();
            Object result = jedis.eval(RELEASE_LOCK_SCRIPT, Collections.singletonList(lockKey),
                    Collections.singletonList(clientId));
            if (RELEASE_SUCCESS.equals(result)) {
                return true;
            }
            return false;
        });
    }

    /**
     * Object转成JSON数据(Gson方式)
     */
    private String toJson(Object object){
        if(object instanceof Integer || object instanceof Long || object instanceof Float ||
                object instanceof Double || object instanceof Boolean || object instanceof String){
            return String.valueOf(object);
        }
        return gson.toJson(object);
    }

    /**
     * JSON数据转成Object(Gson方式)
     */
    private  T fromJson(String json, Class clazz){
        return gson.fromJson(json, clazz);
    }
}
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

public class RequestUtils {

    public static HttpServletRequest getRequest() {
        ServletRequestAttributes ra= (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        return ra.getRequest();
    }

}

import java.util.ArrayList;
import java.util.Map;

import org.apache.http.HttpStatus;
/**
 * 接口统一返回格式
 * @author zhang
 *
 */
public class R1 {

    private static final long serialVersionUID = 1L;

    private int code;

    private T data;

    private String message;

    /**
     * 无参构造
     */
    public R1() {
        this.code = 0;
        this.message = "success";
        this.data = (T) new ArrayList();
    }

    /**
     * 有参构造
     * @param code
     * @param data
     * @param message
     */
    public R1(int code, T data, String message) {
        this.code = code;
        this.data = data;
        this.message = message;
    }

    /**
     * ok————无参返回
     * @return
     */
    public static  R1 ok() {
        return new  R1();
    }

    /**
     * ok————指定提示语
     * @param message
     * @return
     */
    public static  R1 ok(String message) {
        R1 r = new R1();
        r.message = message;
        r.data = (T) new ArrayList();
        return r;
    }

    /**
     * ok————指定data（承载数据）
     * @param map
     * @return
     */
    public static  R1 ok(Map map) {
        R1 r = new R1();
        r.data = (T) map;
        return r;
    }

    /**
     * error————无参返回
     * @return
     */
    public static  R1 error() {
        return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "未知异常，请联系管理员");
    }

    /**
     * error————指定message
     * @param message
     * @return
     */
    public static  R1 error(String message) {
        return error(HttpStatus.SC_INTERNAL_SERVER_ERROR, message);
    }

    /**
     * error————指定code, message
     * @param code
     * @param message
     * @return
     */
    public static  R1 error(int code, String message) {
        R1 r = new R1();
        r.code = code;
        r.message = message;
        r.data = (T) new ArrayList();
        return r;
    }

    /**
     * ok————指定data（承载数据）
     * @param data
     * @return
     */
    public R1 ok(T data) {
        R1 r = new R1();
        r.data = data;
        return r;
    }

    /**
     * 指定data（承载数据）
     * @param data
     * @return
     */
    public static  R1 data(T data) {
        return data(data, "success");
    }

    public static  R1 data(T data, String message) {
        return data(HttpStatus.SC_OK, data, message);
    }

    public static  R1 data(int code, T data, String message) {
        return new R1(code, data, data == null ? "暂无承载数据" : message);
    }

    public int getCode() {
        return this.code;
    }

    public T getData() {
        return this.data;
    }

    public String getmessage() {
        return this.message;
    }

    public void setCode(final int code) {
        this.code = code;
    }

    public void setData(final T data) {
        this.data = data;
    }

    public void setmessage(final String message) {
        this.message = message;
    }

    @Override
    public String toString() {
        return "R1 [code=" + code + ", data=" + data + ", message=" + message + "]";
    }

}
 
  
4.第四写一个提交接口用于测试
 
  
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.zhang.common.annotation.NoRepeatSubmit;
import com.zhang.common.utils.R1;
/**
 * 测试noReatSubmit
 * @author zhang
 *
 */
@RestController
@RequestMapping("/noReatSubmit")
public class NoReatSubmitController {

	@PostMapping("submit")
    @NoRepeatSubmit(lockTime = 30)
    public R1 submit(@RequestBody UserBean userBean) {
        try {
            // 模拟业务场景
        	System.out.println("模拟业务场景开始...，当前请求线程名：" + userBean.getThreadName());
            Thread.sleep(1500);
        } catch (InterruptedException e) {
        	System.out.println("模拟业务场景失败");
            e.printStackTrace();
        }
        System.out.println("模拟业务场景成功，当前请求线程名称：" + userBean.getThreadName());
        return new R1(200, userBean.getUserId(), "成功");
      
    }

    public static class UserBean {
        private String userId;
        
        private String threadName;

        public String getUserId() {
            return userId;
        }

        public void setUserId(String userId) {
            this.userId = userId == null ? null : userId.trim();
        }

		public String getThreadName() {
			return threadName;
		}

		public void setThreadName(String threadName) {
			this.threadName = threadName;
		}

		@Override
		public String toString() {
			return "UserBean [userId=" + userId + ", threadName=" + threadName + "]";
		}

    }
	
} 
  
我这边是多线程模拟多次请求，以HTTP方式请求接口测试。
 
  
5.第五亮出HTTP请求方法工具类HttpClientUtil
 
  
import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.net.ssl.SSLContext;

import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.util.EntityUtils;
/**
 * http请求方式
 * @author zhang
 *
 */
public class HttpClientUtil {

	private static RequestConfig requestConfig;
	private static SSLConnectionSocketFactory sslsf;
	static {
		SSLContext sslContext = null;
		try {
			sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
				// 信任所有证书 https://blog.csdn.net/sleeping_/article/details/50500351
				@Override
				public boolean isTrusted(java.security.cert.X509Certificate[] arg0, String arg1)
						throws java.security.cert.CertificateException {
					return true;
				}
			}).build();
		} catch (Exception e) {
			e.printStackTrace();
		}
		sslsf = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
	}

	/**
	 * get方式請求（有参）
	 * @param url
	 * @param param
	 * @param Authorization 口令授权
	 * @return
	 */
	public static String doGet(String url, Map param, String Authorization, String webAuthorization) {
		// 创建Httpclient对象
		CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
		String resultString = "";
		CloseableHttpResponse response = null;
		try {
			// 创建uri
			URIBuilder builder = new URIBuilder(url);
			if (param != null) {
				for (String key : param.keySet()) {
					if (param.get(key).getClass().isArray()) {
						String[] arr = (String[]) param.get(key);
						for (String string : arr) {
							builder.addParameter(key, string);
						}
					}else{
						builder.addParameter(key, param.get(key).toString());
					}
				}
			}
			URI uri = builder.build();
			// 创建http GET请求
			HttpGet httpGet = new HttpGet(uri);
			httpGet.addHeader("Connection", "close");
			httpGet.addHeader("Authorization", Authorization);
			httpGet.addHeader("Web-Authorization", webAuthorization);
			httpGet.setConfig(requestConfig);
			// 执行请求
			response = httpclient.execute(httpGet);
			// 判断返回状态是否为200
			if (response.getStatusLine().getStatusCode() == 200) {
				resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
				httpclient.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return resultString;
	}

	/**
	 * get方式请求（无参）
	 * @param url
	 * @param Authorization 口令授权
	 * @return
	 */
	public static String doGet(String url, String Authorization, String webAuthorization) {
		return doGet(url, null, Authorization, webAuthorization);
	}

	/**
	 * post方式请求（有参）
	 * @param url
	 * @param param
	 * @param Authorization 口令授权
	 * @return
	 */
	public static String doPost(String url, Map param, String Authorization, String webAuthorization) {
		// 创建Httpclient对象
		CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
		CloseableHttpResponse response = null;
		String resultString = "";
		try {
			// 创建Http Post请求
			HttpPost httpPost = new HttpPost(url);
			httpPost.addHeader("Connection", "close");
			httpPost.addHeader("Authorization", Authorization);
			httpPost.addHeader("Web-Authorization", webAuthorization);
			httpPost.setConfig(requestConfig);
			// 创建参数列表
			if (param != null) {
				List paramList = new ArrayList<>();
				for (String key : param.keySet()) {
					paramList.add(new BasicNameValuePair(key, param.get(key)));
				}
				// 模拟表单
				UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");
				httpPost.setEntity(entity);
			}
			// 执行http请求
			response = httpClient.execute(httpPost);
			resultString = EntityUtils.toString(response.getEntity(), "utf-8");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				response.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return resultString;
	}

	/**
	 * post方式请求（无参）
	 * @param url
	 * @param Authorization 口令授权
	 * @return
	 */
	public static String doPost(String url, String Authorization, String webAuthorization) {
		return doPost(url, null, Authorization, webAuthorization);
	}

	/**
	 * delete方式请求（有参）
	 * @param url
	 * @param param
	 * @param Authorization 口令授权
	 * @return
	 */
	public static String doDelete(String url, String Authorization, String webAuthorization) {
		// 创建Httpclient对象
		CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
		String resultString = "";
		CloseableHttpResponse response = null;
		try {
			// 创建http delete请求
			HttpDelete httpDelete = new HttpDelete(url);
			httpDelete.addHeader("Connection", "close");
			httpDelete.addHeader("Authorization", Authorization);
			httpDelete.addHeader("Web-Authorization", webAuthorization);
			httpDelete.setConfig(requestConfig);
			// 执行请求
			response = httpclient.execute(httpDelete);
			// 判断返回状态是否为200
			if (response.getStatusLine().getStatusCode() == 200) {
				resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
				httpclient.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return resultString;
	}
	
	/**
	 * put方式请求（有参）
	 * @param url
	 * @param param
	 * @param Authorization 口令授权
	 * @return
	 */
	public static String doPut(String url, String json, String Authorization, String webAuthorization) {
		// 创建Httpclient对象
		CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
		CloseableHttpResponse response = null;
		String resultString = "";
		try {
			// 创建Http Post请求
			HttpPut httpPut = new HttpPut(url);
			httpPut.addHeader("Connection", "close");
			httpPut.addHeader("Authorization", Authorization);
			httpPut.addHeader("Web-Authorization", webAuthorization);
			httpPut.setConfig(requestConfig);
			// 创建请求内容
			StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
			httpPut.setEntity(entity);
			// 执行http请求
			response = httpClient.execute(httpPut);
			resultString = EntityUtils.toString(response.getEntity(), "utf-8");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				response.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return resultString;
	}
	
	/**
	 * 请求的参数类型为json
	 * post方式请求 （有参）
	 * @param url
	 * @param json
	 * @param Authorization 口令授权
	 * @return
	 */
	public static String doPostJson(String url, String json, String Authorization, String webAuthorization) {
		// 创建Httpclient对象
		CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
		CloseableHttpResponse response = null;
		String resultString = "";
		try {
			// 创建Http Post请求
			HttpPost httpPost = new HttpPost(url);
			System.out.println("创建Http Post请求");
			httpPost.addHeader("Connection", "close");
			httpPost.addHeader("Authorization", Authorization);
			httpPost.addHeader("Web-Authorization", webAuthorization);
			httpPost.setConfig(requestConfig);
			// 创建请求内容
			StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
			System.out.println("请求内容：" + entity.toString());
			httpPost.setEntity(entity);
			// 执行http请求
			response = httpClient.execute(httpPost);
			resultString = EntityUtils.toString(response.getEntity(), "utf-8");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				response.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return resultString;
	}
	
}

 
  
6.第六步创建线程进行调接口测试RunnableDemo
 
  
import com.alibaba.fastjson.JSONObject;
import com.zhang.common.utils.HttpClientUtil;
import com.zhang.modules.test.controller.NoReatSubmitController.UserBean;
/**
 * 创建线程测试接口
 * @author zhang
 *
 */
public class RunnableDemo implements Runnable {
	
	private Thread t;
	private String threadName;

	public RunnableDemo(String name) {
		threadName = name;
		System.out.println("Creating: " + threadName);
	}

	public String threadName() {
		return threadName;
	}
	
	public void run() {
		System.out.println("Running, threadName = [{}]: " + threadName);
		UserBean userBean = new UserBean();
		userBean.setUserId("123123123");
		userBean.setThreadName(threadName);
		String url="http://localhost:9999/zhang/noReatSubmit/submit";
		HttpClientUtil.doPostJson(url, JSONObject.toJSONString(userBean), "youToken", null);
		System.out.println("Thread " + threadName + " exiting.");
	}

	public void start() {
		System.out.println("Starting " + threadName);
		if (t == null) {
			t = new Thread(this, threadName);
			t.start();
		}
	}
}

 
  
7.第七步，写一个main函数，加上线程启动项目测试
 
  
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import com.zhang.modules.test.controller.RunnableDemo;


@SpringBootApplication 
@ComponentScan(basePackages={"com.zhang"})
public class TestProjectApplication { 

	public static void main(String[] args) {
		SpringApplication.run(TestProjectApplication.class, args);
		System.out.println("启动成功！");

		// 开启线程
	    RunnableDemo R1 = new RunnableDemo( "Thread-1");
	    RunnableDemo R2 = new RunnableDemo( "Thread-2");
//	    RunnableDemo R3 = new RunnableDemo( "Thread-3");
//	    RunnableDemo R4 = new RunnableDemo( "Thread-4");
	    R1.start();
	    R2.start();
//	    R3.start();
//	    R4.start();
	    
	}
}

 
  
测试结果（控制台日志）如下：
 
  
springboot自定义注解使用AOP防止重复提交_第1张图片
 
  
参考链接：
 
  
https://www.toutiao.com/i6768274855004471821/?tt_from=weixin&utm_campaign=client_share&wxshare_count=1&from=groupmessage×tamp=1582519759&app=news_article&utm_source=weixin&utm_medium=toutiao_android&req_id=202002241249180101310981964407620D&group_id=6768274855004471821   ——   Spring Boot 使用 AOP 防止重复提交
 
  
https://www.cnblogs.com/peida/archive/2013/04/24/3036689.html   ——   深入理解Java：注解（Annotation）自定义注解入门
 
  
https://www.cnblogs.com/linjiqin/p/8003838.html   ——   Redis分布式锁的正确实现方式
 
  
http://redisdoc.com/   ——   Redis 命令参考
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(所遇问题,springboot,HTTP)

        

            

                
    
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • swagger访问路径
                        igotyback
swagger
                        
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • Git常用命令－修改远程仓库地址
                        猿大师
LinuxJavagitjava
                        
    查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
    
                    
    • 
                    
  • 利用Requests Toolkit轻松完成HTTP请求
                        nseejrukjhad
http网络协议网络python
                        
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
    
                    
    • 
                    
  • GitHub上克隆项目
                        bigbig猩猩
github
                        
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    
                    
    • 
                    
  • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    
                    
    • 
                    
  • Faiss Tips：高效向量搜索与聚类的利器
                        焦习娜Samantha

                        
    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
    
                    
    • 
                    
  • Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
    
                    
    • 
                    
  • 【无标题】达瓦达瓦
                        JhonKI
考研
                        
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
    
                    
    • 
                    
  • 上图为是否色发
                        JhonKI
考研
                        
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
    
                    
    • 
                    
  • 143234234123432
                        JhonKI
考研
                        
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
    
                    
    • 
                    
  • Python中深拷贝与浅拷贝的区别
                        yuxiaoyu.

                        
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
    
                    
    • 
                    
  • ExpRe[25] bash外的其它shell：zsh和fish
                        tritone
ExpRebashlinuxubuntushell
                        
    文章目录zsh基础配置实用特性插件`autojump`语法高亮自动补全fish优点缺点时效性本篇撰写时间为2021.12.15，由于计算机技术日新月异，博客中所有内容都有时效和版本限制，具体做法不一定总行得通，链接可能改动失效，各种软件的用法可能有修改。但是其中透露的思想往往是值得学习的。本篇前置：ExpRe[10]Ubuntu[2]准备神秘软件、备份恢复软件https://www.cnblogs
    
                    
    • 
                    
  • openssl+keepalived安装部署
                        _小亦_
项目部署keepalivedopenssl
                        
    文章目录OpenSSL安装下载地址编译安装修改系统配置版本Keepalived安装下载地址安装遇到问题安装完成配置文件keepalived运行检查运行状态查看系统日志修改服务service重新加载systemd检查配置文件语法错误OpenSSL安装下载地址考虑到后面设备可能没法连接到外网，所以采用安装包的方式进行部署，下载地址：https://www.openssl.org/source/old/
    
                    
    • 
                    
  • 你可能遗漏的一些C#/.NET/.NET Core知识点
                        追逐时光者
C#.NETDotNetGuide编程指南c#.net.netcoremicrosoft
                        
    前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
    
                    
    • 
                    
  • 「豆包Marscode体验官」 | 云端 IDE 启动 & Rust 体验
                        张风捷特烈
iderust开发语言后端
                        
    theme:cyanosis我正在参加「豆包MarsCode初体验」征文活动MarsCode可以看作一个运行在服务端的远程VSCode开发环境。对于我这种想要学习体验某些语言，但不想在电脑里装环境的人来说非常友好。本文就来介绍一下在MarsCode里，我的体验rust开发体验。一、MarsCode是什么它的本质是:提供代码助手和云端IDE服务的web网站，可通过下面的链接访问https://www
    
                    
    • 
                    
  • Some jenkins settings
                        SnC_

                        
    Jenkins连接到特定gitlabproject的特定branch我采用的方法是在pipeline的script中使用git命令来指定branch。如下：stage('Clonerepository'){steps{gitbranch:'develop',credentialsId:'gitlab-credential-id',url:'http://gitlab.com/repo.git'}}
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • 如何用matlab灵活控制feko的求解
                        NingrLi
matlab开发语言
                        
    https://bbs.rfeda.cn/read.php?tid=3778Feko中的模型和求解设置等都可以通过editfeko进行设置，其文件存储为.pre文件，该文件可以用文本打开，因此，我们可以通过VB、VC、matlab等工具对.pre文件进行读写操作，以达到更灵活的使用feko。同样，对于.out文件，我们也可以进行读操作。熟练使用对.pre文件和.out文件的操作后，我们可以方便的计
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • 光盘文件系统 (iso9660) 格式解析
                        穷人小水滴
光盘文件系统iso9660denoGNU/Linuxjavascript
                        
    越简单的系统,越可靠,越不容易出问题.光盘文件系统(iso9660)十分简单,只需不到200行代码,即可实现定位读取其中的文件.参考资料:https://wiki.osdev.org/ISO_9660相关文章:《光盘防水嘛?DVD+R刻录光盘泡水实验》https://blog.csdn.net/secext2022/article/details/140583910《光驱的内部结构及日常使用》ht
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • 科幻游戏 《外卖员模拟器》 主要地理环境设定 (1)
                        穷人小水滴
游戏科幻设计
                        
    游戏名称:《外卖员模拟器》(英文名称:waimai_se)作者:穷人小水滴本故事纯属虚构,如有雷同实属巧合.故事发生在一个(架空)平行宇宙的地球,21世纪(超低空科幻流派).相关文章:https://blog.csdn.net/secext2022/article/details/141790630目录1星球整体地理设定2巨蛇国主要设定3海蛇市主要设定3.1主要地标建筑3.2交通3.3能源(电力)
    
                    
    • 
                    
  • C++ lambda闭包消除类成员变量
                        barbyQAQ
c++c++java算法
                        
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
    
                    
    • 
                    
  • tiff批量转png
                        诺有缸的高飞鸟
opencv图像处理pythonopencv图像处理
                        
    目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
    
                    
    • 
                    
  • 笋丁网页自动回复机器人V3.0.0免授权版源码
                        希希分享
软希网58soho_cn源码资源笋丁网页自动回复机器人
                        
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
    
                    
    • 
                    
  • 入门MySQL——查询语法练习
                        K_un

                        
    前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
    
                    
    • 
                    
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能
                        小康师兄
ESP32-C3入门教程https服务器esp32OTAMQTT
                        
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
    
                    
    • 
                                
  • 数据采集高并发的架构应用
                                    3golden
.net
                                    
    问题的出发点： 
 
         最近公司为了发展需要，要扩大对用户的信息采集，每个用户的采集量估计约2W。如果用户量增加的话，将会大量照成采集量成3W倍的增长，但是又要满足日常业务需要，特别是指令要及时得到响应的频率次数远大于预期。 
      &n
    
                                
    • 
                                
  • 不停止 MySQL 服务增加从库的两种方式
                                    brotherlamp
linuxlinux视频linux资料linux教程linux自学
                                    
    现在生产环境MySQL数据库是一主一从，由于业务量访问不断增大，故再增加一台从库。前提是不能影响线上业务使用，也就是说不能重启MySQL服务，为了避免出现其他情况，选择在网站访问量低峰期时间段操作。 
 一般在线增加从库有两种方式，一种是通过mysqldump备份主库，恢复到从库，mysqldump是逻辑备份，数据量大时，备份速度会很慢，锁表的时间也会很长。另一种是通过xtrabacku
    
                                
    • 
                                
  • Quartz——SimpleTrigger触发器
                                    eksliang
SimpleTriggerTriggerUtilsquartz
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2208166 一.概述 
SimpleTrigger触发器，当且仅需触发一次或者以固定时间间隔周期触发执行； 
  二.SimpleTrigger的构造函数 
 
 SimpleTrigger(String name, String group)：通过该构造函数指定Trigger所属组和名称； 
 Simpl
    
                                
    • 
                                
  • Informatica应用（1）
                                    18289753290
sqlworkflowlookup组件Informatica
                                    
    1.如果要在workflow中调用shell脚本有一个command组件，在里面设置shell的路径；调度wf可以右键出现schedule，现在用的是HP的tidal调度wf的执行。 
2.designer里面的router类似于SSIS中的broadcast（多播组件）;Reset_Workflow_Var：参数重置 （比如说我这个参数初始是1在workflow跑得过程中变成了3我要在结束时还要
    
                                
    • 
                                
  • python 获取图片验证码中文字
                                    酷的飞上天空
python
                                    
    根据现成的开源项目 http://code.google.com/p/pytesser/改写 
在window上用easy_install安装不上  看了下源码发现代码很少  于是就想自己改写一下 
  
添加支持网络图片的直接解析 
  
  
#coding:utf-8 
#import sys 
#reload(sys) 
#sys.s
    
                                
    • 
                                
  • AJAX
                                    永夜-极光
Ajax
                                    
    1.AJAX功能:动态更新页面,减少流量消耗,减轻服务器负担 
  
2.代码结构: 
   
<html>

<head>
<script type="text/javascript">
function loadXMLDoc()
{
.... AJAX script goes here ...

    
                                
    • 
                                
  • 创业OR读研
                                    随便小屋
创业
                                    
            现在研一，有种想创业的想法，不知道该不该去实施。因为对于的我情况这两者是矛盾的，可能就是鱼与熊掌不能兼得。 
       
        研一的生活刚刚过去两个月，我们学校主要的是
    
                                
    • 
                                
  • 需求做得好与坏直接关系着程序员生活质量
                                    aijuans
IT 生活
                                    
      
        这个故事还得从去年换工作的事情说起，由于自己不太喜欢第一家公司的环境我选择了换一份工作。去年九月份我入职现在的这家公司，专门从事金融业内软件的开发。十一月份我们整个项目组前往北京做现场开发，从此苦逼的日子开始了。 
       系统背景：五月份就有同事前往甲方了解需求一直到6月份，后续几个月也完
    
                                
    • 
                                
  • 如何定义和区分高级软件开发工程师
                                    aoyouzi

                                    
    在软件开发领域，高级开发工程师通常是指那些编写代码超过 3 年的人。这些人可能会被放到领导的位置，但经常会产生非常糟糕的结果。Matt Briggs 是一名高级开发工程师兼 Scrum 管理员。他认为，单纯使用年限来划分开发人员存在问题，两个同样具有 10 年开发经验的开发人员可能大不相同。近日，他发表了一篇博文，根据开发者所能发挥的作用划分软件开发工程师的成长阶段。 
　　初
    
                                
    • 
                                
  • Servlet的请求与响应
                                    百合不是茶
servletget提交java处理post提交
                                    
      
Servlet是tomcat中的一个重要组成,也是负责客户端和服务端的中介 
  
  
1,Http的请求方式(get  ,post); 
  客户端的请求一般都会都是Servlet来接受的,在接收之前怎么来确定是那种方式提交的,以及如何反馈,Servlet中有相应的方法,  http的get方式 servlet就是都doGet(
    
                                
    • 
                                
  • web.xml配置详解之listener
                                    bijian1013
javaweb.xmllistener
                                    
    一.定义 
<listener>  
	<listen-class>com.myapp.MyListener</listen-class>  
</listener> 
  
二.作用        该元素用来注册一个监听器类。可以收到事件什么时候发生以及用什么作为响
    
                                
    • 
                                
  • Web页面性能优化（yahoo技术）
                                    Bill_chen
JavaScriptAjaxWebcssYahoo
                                    
    1.尽可能的减少HTTP请求数 content 
2.使用CDN server 
3.添加Expires头(或者 Cache-control) server 
4.Gzip 组件 server 
5.把CSS样式放在页面的上方。 css 
6.将脚本放在底部(包括内联的) javascript 
7.避免在CSS中使用Expressions css 
8.将javascript和css独立成外部文
    
                                
    • 
                                
  • 【MongoDB学习笔记八】MongoDB游标、分页查询、查询结果排序
                                    bit1129
mongodb
                                    
    游标 
  
游标，简单的说就是一个查询结果的指针。游标作为数据库的一个对象，使用它是包括 
 
 声明 
 打开 
 循环抓去一定数目的文档直到结果集中的所有文档已经抓取完 
 关闭游标 
 
  
游标的基本用法，类似于JDBC的ResultSet(hasNext判断是否抓去完,next移动游标到下一条文档)，在获取一个文档集时，可以提供一个类似JDBC的FetchSize
    
                                
    • 
                                
  • ORA-12514 TNS 监听程序当前无法识别连接描述符中请求服务 的解决方法
                                    白糖_
ORA-12514
                                    
     今天通过Oracle SQL*Plus连接远端服务器的时候提示“监听程序当前无法识别连接描述符中请求服务”，遂在网上找到了解决方案： 
 ①打开Oracle服务器安装目录\NETWORK\ADMIN\listener.ora文件，你会看到如下信息： 
  
# listener.ora Network Configuration File: D:\database\Oracle\net
    
                                
    • 
                                
  • Eclipse 问题 A resource exists with a different case
                                    bozch
eclipse
                                    
    在使用Eclipse进行开发的时候，出现了如下的问题： 
Description Resource Path Location TypeThe project was not built due to "A resource exists with a different case: '/SeenTaoImp_zhV2/bin/seentao'.&
    
                                
    • 
                                
  • 编程之美-小飞的电梯调度算法
                                    bylijinnan
编程之美
                                    
    

public class AptElevator {

	/**
	 * 编程之美 小飞 电梯调度算法
	 * 在繁忙的时间，每次电梯从一层往上走时，我们只允许电梯停在其中的某一层。
	 * 所有乘客都从一楼上电梯，到达某层楼后，电梯听下来，所有乘客再从这里爬楼梯到自己的目的层。
	 * 在一楼时，每个乘客选择自己的目的层，电梯则自动计算出应停的楼层。
	 * 问：电梯停在哪
    
                                
    • 
                                
  • SQL注入相关概念
                                    chenbowen00
sqlWeb安全
                                    
    SQL Injection：就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。 
 
具体来说，它是利用现有应用程序，将（恶意）的SQL命令注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。 
 
首先让我们了解什么时候可能发生SQ
    
                                
    • 
                                
  • [光与电]光子信号战防御原理
                                    comsci
原理
                                    
     
 
      无论是在战场上,还是在后方,敌人都有可能用光子信号对人体进行控制和攻击,那么采取什么样的防御方法,最简单,最有效呢? 
 
      我们这里有几个山寨的办法,可能有些作用,大家如果有兴趣可以去实验一下 
 
      根据光
    
                                
    • 
                                
  • oracle 11g新特性:Pending Statistics
                                    daizj
oracledbms_stats
                                    
    oracle 11g新特性:Pending Statistics 转 
 
从11g开始，表与索引的统计信息收集完毕后，可以选择收集的统信息立即发布，也可以选择使新收集的统计信息处于pending状态，待确定处于pending状态的统计信息是安全的，再使处于pending状态的统计信息发布，这样就会避免一些因为收集统计信息立即发布而导致SQL执行计划走错的灾难。 
 
在 11g 之前的版本中，D
    
                                
    • 
                                
  • 快速理解RequireJs
                                    dengkane
jqueryrequirejs
                                    
    RequireJs已经流行很久了，我们在项目中也打算使用它。它提供了以下功能： 
 
 声明不同js文件之间的依赖 
 可以按需、并行、延时载入js库 
 可以让我们的代码以模块化的方式组织 
 
初看起来并不复杂。 在html中引入requirejs 
在HTML中，添加这样的 <script> 标签： 
<script src="/path/to
    
                                
    • 
                                
  • C语言学习四流程控制if条件选择、for循环和强制类型转换
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int i, j;

	scanf("%d %d", &i, &j);

	if (i > j)
		printf("i大于j\n");
	else
		printf("i小于j\n");

	retu
    
                                
    • 
                                
  • dictionary的使用要注意
                                    dcj3sjt126com
IO
                                    
    NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:
                          user.user_id , @"id",
                          user.username , @"username",
         
    
                                
    • 
                                
  • Android 中的资源访问(Resource)
                                    finally_m
xmlandroidStringdrawablecolor
                                    
     
简单的说，Android中的资源是指非代码部分。例如，在我们的Android程序中要使用一些图片来设置界面，要使用一些音频文件来设置铃声，要使用一些动画来显示特效，要使用一些字符串来显示提示信息。那么，这些图片、音频、动画和字符串等叫做Android中的资源文件。 
在Eclipse创建的工程中，我们可以看到res和assets两个文件夹，是用来保存资源文件的，在assets中保存的一般是原生
    
                                
    • 
                                
  • Spring使用Cache、整合Ehcache
                                    234390216
springcacheehcache@Cacheable
                                    
    Spring使用Cache 
  
  
       从3.1开始，Spring引入了对Cache的支持。其使用方法和原理都类似于Spring对事务管理的支持。Spring Cache是作用在方法上的，其核心思想是这样的：当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中，等到下次利用同样的
    
                                
    • 
                                
  • 当druid遇上oracle blob(clob)
                                    jackyrong
oracle
                                    
    http://blog.csdn.net/renfufei/article/details/44887371 
 
众所周知，Oracle有很多坑, 所以才有了去IOE。 
 
在使用Druid做数据库连接池后，其实偶尔也会碰到小坑，这就是使用开源项目所必须去填平的。【如果使用不开源的产品，那就不是坑，而是陷阱了，你都不知道怎么去填坑】 
 
用Druid连接池，通过JDBC往Oracle数据库的
    
                                
    • 
                                
  • easyui datagrid pagination获得分页页码、总页数等信息
                                    ldzyz007

                                    
    var grid = $('#datagrid');  
var options = grid.datagrid('getPager').data("pagination").options;  
var curr = options.pageNumber;  
var total = options.total;  
var max =
    
                                
    • 
                                
  • 浅析awk里的数组
                                    nigelzeng
二维数组array数组awk
                                    
    awk绝对是文本处理中的神器，它本身也是一门编程语言，还有许多功能本人没有使用到。这篇文章就单单针对awk里的数组来进行讨论，如何利用数组来帮助完成文本分析。 
  
有这么一组数据： 
   abcd,91#31#2012-12-31 11:24:00 
case_a,136#19#2012-12-31 11:24:00 
case_a,136#23#2012-12-31 1
    
                                
    • 
                                
  • 搭建 CentOS 6 服务器(6) - TigerVNC
                                    rensanning
centos
                                    
    安装GNOME桌面环境 
 
# yum groupinstall "X Window System" "Desktop" 
 
 
安装TigerVNC 
 
# yum -y install tigervnc-server tigervnc 
 
 
启动VNC服务 
 
# /etc/init.d/vncserver restart
# vncser
    
                                
    • 
                                
  • Spring 数据库连接整理
                                    tomcat_oracle
springbeanjdbc
                                    
    1、数据库连接jdbc.properties配置详解  　　jdbc.url=jdbc:hsqldb:hsql://localhost/xdb   　　jdbc.username=sa   　　jdbc.password=   　　jdbc.driver=不同的数据库厂商驱动，此处不一一列举   　　接下来，详细配置代码如下：   　　 
Spring连接池      
    
                                
    • 
                                
  • Dom4J解析使用xpath java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常
                                    xp9802

                                    
    用Dom4J解析xml,以前没注意,今天使用dom4j包解析xml时在xpath使用处报错 
     异常栈：java.lang.NoClassDefFoundError: org/jaxen/JaxenException异常  
     导入包 jaxen-1.1-beta-6.jar 解决; 
&nb
    
                                
    •