配置SpringBoot的全局事务，解决在Controller中使用SessionFactory必须要使用注解@Transactional的问题

增加以下两个配置文件：

TransactionAdviceConfig.java

package com.zero4j.config;


import org.aspectj.lang.annotation.Aspect;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;
import org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionInterceptor;

@Aspect
@Configuration
public class TransactionAdviceConfig {

	 //使dao使用session
	private static final String AOP_POINTCUT_EXPRESSION = " (execution(* com..dao..*.*(..))) ";
	//controller由过滤器中进行设置，这里设置会抽风
	/*private static final String AOP_POINTCUT_EXPRESSION2 = " (execution(* com..controller..*.*(..))) ";*/
	 
	 
    @Autowired
    private PlatformTransactionManager transactionManager;

    @Bean
    public TransactionInterceptor txAdvice() {

        DefaultTransactionAttribute txAttr_REQUIRED = new DefaultTransactionAttribute();
        txAttr_REQUIRED.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

        DefaultTransactionAttribute txAttr_REQUIRED_READONLY = new DefaultTransactionAttribute();
        txAttr_REQUIRED_READONLY.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        txAttr_REQUIRED_READONLY.setReadOnly(true);
        
        
        DefaultTransactionAttribute txAttr_READONLY = new DefaultTransactionAttribute();
        txAttr_READONLY.setReadOnly(true);
        
        

        NameMatchTransactionAttributeSource source = new NameMatchTransactionAttributeSource();

        source.addTransactionalMethod("save*", txAttr_REQUIRED);
        source.addTransactionalMethod("add*", txAttr_REQUIRED);
        source.addTransactionalMethod("create*", txAttr_REQUIRED);
        source.addTransactionalMethod("insert*", txAttr_REQUIRED);
        source.addTransactionalMethod("update*", txAttr_REQUIRED);
        source.addTransactionalMethod("merge*", txAttr_REQUIRED);
        source.addTransactionalMethod("del*", txAttr_REQUIRED);
        source.addTransactionalMethod("remove*", txAttr_REQUIRED);
        source.addTransactionalMethod("put*", txAttr_REQUIRED);
        source.addTransactionalMethod("use*", txAttr_REQUIRED);
        source.addTransactionalMethod("exec*", txAttr_REQUIRED);
        source.addTransactionalMethod("set*", txAttr_REQUIRED);
        
        
        source.addTransactionalMethod("get*", txAttr_REQUIRED_READONLY);//特殊，service在save后会重新读取，如果设置成REQUIRED_READONLY,则save不会保存数据
        source.addTransactionalMethod("count*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("find*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("list*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("query*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("find*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("is*", txAttr_REQUIRED_READONLY);
        
        /*
        source.addTransactionalMethod("save*", txAttr_REQUIRED);
        source.addTransactionalMethod("delete*", txAttr_REQUIRED);
        source.addTransactionalMethod("update*", txAttr_REQUIRED);
        source.addTransactionalMethod("exec*", txAttr_REQUIRED);
        source.addTransactionalMethod("set*", txAttr_REQUIRED);
        source.addTransactionalMethod("get*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("query*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("find*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("list*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("count*", txAttr_REQUIRED_READONLY);
        source.addTransactionalMethod("is*", txAttr_REQUIRED_READONLY);
        
        */
        source.addTransactionalMethod("*", txAttr_READONLY);
        return new TransactionInterceptor(transactionManager, source);
    }

    @Bean
    public Advisor txAdviceAdvisor() {
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression( AOP_POINTCUT_EXPRESSION );
        return new DefaultPointcutAdvisor(pointcut, txAdvice());
    }
    
   /* @Bean
    public Advisor txAdviceAdvisor2() {
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression( AOP_POINTCUT_EXPRESSION2 );
        return new DefaultPointcutAdvisor(pointcut, txAdvice());
    }*/
}

FilterConfig.java

package com.zero4j.config;


import org.aspectj.lang.annotation.Aspect;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.hibernate5.support.OpenSessionInViewFilter;

@Aspect
@Configuration
public class FilterConfig {

	//解决调用接口时session抽风的问题
	@Bean
	public FilterRegistrationBean<OpenSessionInViewFilter> testFilterRegistration() {	
		FilterRegistrationBean<OpenSessionInViewFilter> registration = new FilterRegistrationBean<>();
		registration.setFilter(new OpenSessionInViewFilter());
		registration.addUrlPatterns("/*");//配置过滤路径
		return registration;
	}
	
}

 

CentOS下安装并配置vsftp

1、安装vsftp并启动服务

使用以下命令进行安装：

yum install vsftpd

安装完毕后，使用以下命令启动服务：

systemctl start vsftpd
systemctl status vsftpd

并查看服务的启动状态：vsftp安装并启动成功

 

 

如需要设置开机启动，则使用以下命令：

systemctl enable vsftpd

2、开启匿名用户，测试vsftp

使用 vi /etc/vsftpd/vsftpd.conf 编辑配置，确保以下三项为YES：

anonymous_enable=YES
anon_upload_enable=YES
anon_mkdir_write_enable=YES

 

开启vsftp的匿名访问

 

保存后使用以下命令重启vsftp从而让配置生效：

systemctl restart vsftpd

2.1 测试内网是否正常

使用以下命令安装ftp工具

yum install ftp

安装后使用anonymous匿名用户登录（无需登录密码）

ftp localhost

如图所示：

ftp登录内网测试

 

220表示服务正常，可以登陆；230表示登陆成功。

在ftp工具内使用ls命令可以查看文件夹信息：

ftp工具查看文件夹信息

 

2.2 测试外网是否正常

直接在浏览器中输入”ftp://ip/”后，使用匿名用户登录看是否正常：

ftp外网浏览器测试

建议使用cuteFtp工具进行连接，这样在连接使用时内看到错误信息

2.3 创建正式用的远程登录账号

2.3.1 配置vsftp

使用 vi /etc/vsftpd/vsftpd.conf 修改vsftp的配置：

anonymous_enable=YES 改为 NO（意思是禁止匿名用户登录）

#是否允许匿名用户登录(默认为YES)
anonymous_enable=NO

将下图两行代码前的#号去掉，代表对chroot_list文件内的用户进行限制

#是否对chroot_list文件内的用户进行限制(默认为NO)
chroot_list_enable=YES
# (default follows)
chroot_list_file=/etc/vsftpd/chroot_list

在文件最后面新增 allow_writeable_chroot=YES，表示允许已登录用户进行上传

#是否已登录用户进行上传(默认无此配置)
allow_writeable_chroot=YES

2.3.2 创建对应的FTP用户

使用以下命令创建不允许进行shell登录的ftp用户：

useradd -d /home/ftptest -s /sbin/nologin ftptest

然后使用以下命令将刚刚创建的用户放在ftp用户组中：

usermod -aG ftp ftptest

分配目录操作权限给刚刚创建的ftp用户：

chown ftptest /home/ftptest

使用以下命令修改刚刚创建的ftp用户密码：

passwd ftptest

使用“vi /etc/vsftpd/chroot_list”命令修改用户登录名单：

vsftp登录用户

然后使用ftp工具进行连接测试。

如果遇到密码明明正确但是始终提示503密码错误的情况，可修改“vi /etc/pam.d/vsftpd”文件，注释掉：

#auth    required pam_shells.so

然后重启vsftp：

systemctl restart vsftpd

2.3.3 访问速度过慢的配置调整

编辑 /etc/vsftpd/vsftpd.conf 配置文件，在最下面添加以下信息：

#以下配置是为了解决连接超时的问题
#开启被动模式(默认无此配置)
pasv_enable=YES
pasv_min_port=4000	#随机最小端口
pasv_max_port=5000	#随机最大端口
#关闭DNS反向解析(默认无此配置)
reverse_lookup_enable=NO

以上代码实现两个功能：

  • 开启PASV被动访问模式
  • 关闭DNS反向解析

然后重启vsftp：

systemctl restart vsftpd

 

 

 

SpringBoot利用Redis对session进行共享

1、引入pom依赖包

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-data-redis</artifactId>
</dependency>

2、配置application.application

# spring session使用存储类型
spring.session.store-type=redis

#配置redis集群

spring.redis.cluster.nodes=192.168.1.55:7000,192.168.1.53:7003

3、启动类中增加@EnableRedisHttpSession

4、使用
request.getSession().setAttribute(“username”, “admin”);
String userName = (String) request.getSession().getAttribute(“username”);

SpringBoot2+JPA引入对Redis的支持

在pom.xml加入：

        <!-- 对Redis的支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

增加配置文件RedisConfig.java：

package com.zero4j.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import java.lang.reflect.Method;

/**
 * Redis 缓存配置类（通用）
 * @author linhongcun
 *
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 缓存对象集合中，缓存是以 key-value 形式保存的。当不指定缓存的 key 时，SpringBoot 会使用 SimpleKeyGenerator 生成 key。
     * @return
     */
    @Bean
    public KeyGenerator wiselyKeyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };

    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
    	return RedisCacheManager.create(factory);
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        @SuppressWarnings({ "rawtypes", "unchecked" })
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

在application.properties中加入：

# Redis
spring.redis.host=127.0.0.1
spring.redis.port=6379

对Service类加入注解@CacheConfig和@Cacheable，如：

package com.zero4j.model.config;

import java.util.List;

import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

@Repository
@CacheConfig(cacheNames = "configRepository")
public interface ConfigRepository extends JpaRepository<Config, String> {

	@Query("SELECT config FROM Config config")
	@Cacheable(value = "findAll",keyGenerator="wiselyKeyGenerator")
	List<Config> findAll();
	
}

 

研究SpringBoot与非SpringBoot项目以及搭配MyBatis/JPA/Hibernate的并发性能浅度测试

测试环境服务器参数：

CPU：4核8G带宽200M
RDS：1核1G
操作系统：Linux
JDK版本：1.8
WEB容器：Tomcat 8
压测工具：JMeter 3.2

每个组合分别的test内容基本如下（根据搭配的数据库不同，有些方法命名稍有差异）：

@Controller
@RequestMapping("")
public class RootController {
	
	@Autowired
    private UserService userService;
	
	@RequestMapping(value={"","/","/index"})
	String view(Map<String, Object> map){
    	
    	System.out.println("首页(default)");
    	
    	map.put("name", "SpringBoot");
		map.put("date", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    	
  		return "index.jsp";
  		
  	}
	
	@RequestMapping(value={"test1"})
	@ResponseBody
	String test() {

		String str = "(new Random()).nextInt() = "+(new Random()).nextInt();
		
		System.out.println(str);
		
		return str;
		
    }
	
	@RequestMapping(value="test2")
  	public void test2(HttpServletRequest request, HttpServletResponse response) {

		String str = "(new Random()).nextInt() = "+(new Random()).nextInt();
		
		System.out.println(str);
		
		ResponseStaticUtil.write(response, str);
  	}
	
	@RequestMapping(value={"get1"})
	@ResponseBody
	String get1() {

		User user = this.userService.get(1);
		String str = "user = "+user.getName()+" / (new Random()).nextInt() = "+(new Random()).nextInt();
		
		System.out.println(str);
		
		return str;
		
    }
	
  	@RequestMapping(value="get2")
  	public void get2(HttpServletRequest request, HttpServletResponse response) {
  		
  		User user = this.userService.get(1);
		String str = "user = "+user.getName()+" / (new Random()).nextInt() = "+(new Random()).nextInt();
		
		System.out.println(str);
  		
  		ResponseStaticUtil.write(response, str);
  	}
	
	@RequestMapping(value={"list1"})
	@ResponseBody
	String list() {

		List<User> users = this.userService.listAll();
		String str = "users.size()= "+users.size()+" / (new Random()).nextInt() = "+(new Random()).nextInt();
		System.out.println(str);
		
		return str;
		
    }
	
	@RequestMapping(value="list2")
  	public void list2(HttpServletRequest request, HttpServletResponse response) {

		List<User> users = this.userService.listAll();
		String str = "users.size()= "+users.size()+" / (new Random()).nextInt() = "+(new Random()).nextInt();
		System.out.println(str);
		
		ResponseStaticUtil.write(response, str);
		
    }
	
}

 

普通SpringMVC+Hibernate项目的各Controller压力测试结果：
123

SpringBoot+MyBatis项目的各Controller压力测试结果：
SpringBoot+Hibernate项目的各Controller压力测试结果

 

SpringBoot+JPA项目的各Controller压力测试结果：
123

SpringBoot+Hibernate项目的各Controller压力测试结果：
123

 

” SpringBoot+MyBatis / SpringBoot+JPA / SpringBoot+Hibernate ” 的get单个user对象压力测试对比：
" SpringBoot+MyBatis / SpringBoot+JPA / SpringBoot+Hibernate " 的get单个user对象压力测试对比

” SpringBoot+MyBatis / SpringBoot+JPA / SpringBoot+Hibernate ” 的获取user所有对象（只有3个数据）压力测试对比：
" SpringBoot+MyBatis / SpringBoot+JPA / SpringBoot+Hibernate " 的获取user所有对象（只有3个数据）压力测试对比

 

总结：

1、在写Controller方法时，普通SpringMVC框架在使用普通的response.write的方式时效率很高，但使用annotation的方式返回数据时效率十分低；反之，使用SpringBoot框架在使用annotation的方式返回数据时效率比传统的response.write方式的运行效率要高出一截。

2、在SpringBoot框架下搭配分别搭配MyBatis、JPA、Hibernate时，其运行效率的差异不大，JPA的方式稍弱一点点。

 

本文属于“cp锋”的原创，虽然内容不是十分精品，但还望尊重本人的研究成果，转发时请注明转载并带上本页面链接，感谢~

Spring boot设置文件上传大小限制

Spring Boot做文件上传时出现了报错

The field file exceeds its maximum permitted size of 1048576 bytes

显示文件的大小超出了允许的范围。查看了官方文档，原来Spring Boot工程嵌入的tomcat限制了请求的文件大小默认为1MB,单次请求的文件的总数不能大于10Mb.要更改这个默认值需要在配置文件（如application.properties）中加入两个配置.

springboot 1.4之前是这样的：

multipart.maxFileSize = 10485760       //单个文件的大小
multipart.maxRequestSize = 10485760     //单次请求的文件的总大小

springboot 1.4之后是这样的：

spring.http.multipart.maxFileSize = 10485760
spring.http.multipart.maxRequestSize = 10485760

springboot 2.0之后是这样的：

spring.servlet.multipart.max-file-size = 10485760
spring.servlet.multipart.max-request-size = 10485760

注意：很多其他网站是让你们用10Mb这样的形式去赋值的，但事实上这样会报错，这里的单位是以字节b为单位的，我们可以调成他原来的1048576 bytes的10倍，也就是10MB大概等于10485760

JAVA的各种HTTP/HTTPS模拟请求使用经验汇总

https:

try{
			

			
		StringBuffer reultBuffer = new StringBuffer();
			
		KeyStore keyStore  = KeyStore.getInstance("PKCS12");
		FileInputStream instream = new FileInputStream(new File("/home/certificate/apiclient_cert.p12"));
	        String passwordssss=mch_id;
	        keyStore.load(instream, passwordssss.toCharArray());	//证书密码
	        instream.close();
	        SSLContext sslcontext = SSLContexts.custom().loadKeyMaterial(keyStore, passwordssss.toCharArray()).build();	//证书密码（初始是商户ID）
	        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext,new String[] { "TLSv1" },null,SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
	        
		HttpPost httpPost = new HttpPost("https://fraud.mch.weixin.qq.com/risk/getpublickey");
	        CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
	        httpPost.setHeader("Content-Type", "text/xml; charset=UTF-8");
	        httpPost.setEntity(new StringEntity(str_lingqian.toString(),"UTF-8"));
	        
	        CloseableHttpResponse response      = null;
	        InputStream inputStream		        = null;
	        InputStreamReader inputStreamReader = null;
	        BufferedReader bufferedReader       = null;
	        try {
	        	response = httpclient.execute(httpPost);
	        	HttpEntity entity = response.getEntity();
				if (entity!=null){
					inputStream = entity.getContent();
					inputStreamReader = new InputStreamReader(inputStream,"UTF-8");
					bufferedReader = new BufferedReader(inputStreamReader);
					String str = null;
					while ((str = bufferedReader.readLine()) != null) {
						reultBuffer.append(str);
						System.out.println(str);
					}
				}
			} catch (ClientProtocolException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}finally{

				httpclient.close();
				response.close();
				bufferedReader.close();
				inputStreamReader.close();
				inputStream.close();
				inputStream = null;
			}
	     
	        Document document = DocumentHelper.parseText(reultBuffer.toString());
	        Element rootElm = document.getRootElement();
	        if(rootElm.elementText("return_code").toString().equals("SUCCESS") && rootElm.elementText("result_code").toString().equals("SUCCESS") ){
	        	pub_key = rootElm.elementText("pub_key").toString();
	        	System.out.println("pub_key = "+pub_key);
	        }else{	        	
	        	return status;
	        }
			
}catch(Exception e){
	e.printStackTrace();
}

 

阿里云Centos7使用yum安装MySQL5.6

centos自带的repo是不会自动更新每个软件的最新版本，所以无法通过yum方式安装MySQL的高级版本。

先安装带有可用的mysql5系列社区版资源的rpm包

rpm -Uvh http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm

查看当前可用的mysql安装资源

yum repolist enabled | grep "mysql.*-community.*"
mysql-connectors-community/x86_64 MySQL Connectors Community                  17
mysql-tools-community/x86_64      MySQL Tools Community                       31
mysql56-community/x86_64          MySQL 5.6 Community Server                 199

这个时候我们可以直接使用yum的方式安装MySQL了

yum -y install mysql-community-server

加入开机启动

systemctl enable mysqld

安装结束

close