Spring Boot 学习之项目构建

package com.controller;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.WebApplicationContext;

import com.base.BaseController;
import com.base.StringTools;
import com.businesses.BaseBusiness;

@RestController
@Scope("prototype")
@RequestMapping("/adapter")
public class AdapterController extends BaseController {
    
    @Autowired  
    WebApplicationContext context;
    
    @RequestMapping("/{businessName}/{methodName}")
    public void executeAPI( @PathVariable String businessName,
            @PathVariable String methodName) throws Exception {
        Map<String, Object> map = new HashMap<String, Object>();
        String status = "0";
        String message = "success";
        String excep = "";
        businessName += "BusinessImpl";
        String request_json = null;
        try {
            request_json = StringTools.getStreamString(request.getInputStream());
            BaseBusiness business = (BaseBusiness) context
                    .getBean(businessName);
            Method method = null;
            Object result = null;
            method = business.getClass().getMethod(methodName, String.class);
            result = method.invoke(business, request_json);
            map.put("result", result);

        } catch (InvocationTargetException e) {
            message = e.getTargetException().getMessage();
            status = "500";
            excep = e.getTargetException().getMessage();
            log.error("excuteAPI Exception...", e);
            //此处设置后台全局异常处理使用
            //throw new RuntimeException();
        } catch (Exception e) {
            status = "500";
            message = e.getMessage();
            excep = e.getMessage();
            log.error("excuteAPI Exception...", e);
            //此处设置后台全局异常处理使用
            //throw new RuntimeException();
        }
        map.put("status", status);
        map.put("message", message);
        map.put("message_detail", excep);
        super.ajaxResponse(map);
    }
}

package com.dao;

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

import com.model.Member;
@CacheConfig(cacheNames = "memberCache")
public interface MemberRepository extends JpaRepository<Member,Long>{
    @Cacheable
    Member findByMobile(String mobile);
    
    @Cacheable
    Member findById(Long id);
}

#dbcp2连接配置
spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource
#初始化连接数量,默认值0
spring.datasource.dbcp2.initial-size=10
#最大空闲连接:连接池中容许保持空闲状态的最大连接数量,超过的空闲连接将被释放,如果设置为负数表示不限制,默认值8
spring.datasource.dbcp2.max-idle=20
#最小空闲连接:连接池中容许保持空闲状态的最小连接数量,低于这个数量将创建新的连接,如果设置为0则不创建,默认值0
spring.datasource.dbcp2.min-idle=10
#最大等待时间:当没有可用连接时,连接池等待连接被归还的最大时间(以毫秒计数),超过时间则抛出异常,如果设置为-1表示无限等待
spring.datasource.dbcp2.max-wait-millis=-1
#连接池创建的连接的默认的TransactionIsolation状态.
spring.datasource.dbcp2.default-transaction-isolation=1
#连接池创建的连接的默认的auto-commit状态
spring.datasource.dbcp2.default-auto-commit=true
#连接池创建的连接的默认的read-only状态. 如果没有设置则setReadOnly方法将不会被调用.(某些驱动不支持只读模式,比如:Informix)
spring.datasource.dbcp2.default-read-only=false

#指明是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个.
#注意: 设置为true后如果要生效,validationQuery参数必须设置为非空字符串
spring.datasource.dbcp2.test-on-borrow=false

#指明连接是否被空闲连接回收器(如果有)进行检验.如果检测失败,则连接将被从池中去除.
#注意: 设置为true后如果要生效,validationQuery参数必须设置为非空字符串
spring.datasource.dbcp2.test-while-idle=true
#在空闲连接回收器线程运行期间休眠的时间值,以毫秒为单位.如果设置为非正数,则不运行空闲连接回收器线程
spring.datasource.dbcp2.time-between-eviction-runs-millis=-1
#在每次空闲连接回收器线程(如果有)运行时检查的连接数量
spring.datasource.dbcp2.num-tests-per-eviction-run=5

package com.interceptor;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
//添加拦截器,设置拦截范围,排除拦截范围
@Configuration
public class InterceptorHandler extends WebMvcConfigurerAdapter {
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new CustomInterceptor())
            .addPathPatterns("/**")
            .excludePathPatterns("/adapter/member/addMember");
    }
}

package com.linerunner;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import com.client.RedisClient;
import com.dao.MemberRepository;
import com.model.Member;

@Component
@Order(1)
public class CustomCommandLineRunner implements CommandLineRunner {
    
    @Autowired
    MemberRepository memberRepository;
    
    @Autowired  
    private RedisClient redisClinet;
    
    @Override
    public void run(String... arg0) throws Exception {
        System.out.println("--------第一个看看什么时候执行-----------");
        
        List<Member> list = memberRepository.findAll();
        for (Member member : list) {
            redisClinet.set(member.getId().toString(), member.getMobile());
            System.out.println("redis 服务器获取到    --- " + redisClinet.get(member.getId().toString()));
        }
    }

}

package com.listener;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.web.context.WebApplicationContext;

public class CustomApplicationListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent>{

    @Autowired
    WebApplicationContext wac;
    
    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        System.out.println("---------启动前的listener-----------");
    }


}

package com.exception;

import javax.servlet.http.HttpServletResponse;

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import com.bean.response.ExceptionResponse;

@RestControllerAdvice  
public class GlobalExceptionHandler { 
    
    @ExceptionHandler(RuntimeException.class)  
    public ExceptionResponse exceptionHandler(RuntimeException e, HttpServletResponse response) {  
        ExceptionResponse resp = new ExceptionResponse();
        resp.setCoed("100");
        resp.setMessage("全局异常处理");
        return resp;  
    }
    
} 

package com.client;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.JedisPool;  
  
@Component  
public class RedisClient {  
  
    Logger log = Logger.getLogger(RedisClient.class);
    
    @Autowired  
    private JedisPool jedisPool;  
      
    public void set(String key, String value) {  
        try(Jedis jedis =jedisPool.getResource()) {  
            jedis.set(key, value);  
        } catch(Exception e) {
            log.error("jedisPoll 存储数据   出错了  ....", e);
        }
    }  
    
    public String get(String key) throws Exception  {  
  
        try(Jedis jedis =jedisPool.getResource()) {  
            return jedis.get(key);  
        } catch(Exception e) {
            log.error("jedisPoll 存储数据   出错了  ....", e);
            return null;
        }
    } 
}  

//1命令行参数。
//2properties
//yml
//昂,还需要研究一下,待补充

package com.config;
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.beans.factory.annotation.Qualifier;  
import org.springframework.beans.factory.annotation.Value;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
  
import redis.clients.jedis.JedisPool;  
import redis.clients.jedis.JedisPoolConfig;  
  
@Configuration  
public class RedisConfiguration {  
      
    @Bean(name= "jedis.pool")  
    @Autowired  
    public JedisPool jedisPool(@Qualifier("jedis.pool.config") JedisPoolConfig config,   
                @Value("${jedis.pool.host}")String host,   
                @Value("${jedis.pool.port}")int port) {  
        return new JedisPool(config, host, port);  
    }  
      
    @Bean(name= "jedis.pool.config")  
    public JedisPoolConfig jedisPoolConfig (@Value("${jedis.pool.config.maxTotal}")int maxTotal,  
                                @Value("${jedis.pool.config.maxIdle}")int maxIdle,  
                                @Value("${jedis.pool.config.maxWaitMillis}")int maxWaitMillis) {  
        JedisPoolConfig config = new JedisPoolConfig();  
        config.setMaxTotal(maxTotal);  
        config.setMaxIdle(maxIdle);  
        config.setMaxWaitMillis(maxWaitMillis);
        config.setTestOnBorrow(false);
        config.setTestOnReturn(false);
        return config;  
    }  
      
}