使用IDEA快速搭建基于Maven的SpringBoot项目(集成使用Redis)
迫于好久没写博客心慌慌，随便写个简单版的笔记便于查阅。
新建项目
新建项目 然后起名 继续next netx finish。
首先附上demo的项目结构图
配置pom.xml
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.9.RELEASE</version> <!-- 我这里用的1.5.9 --> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.blaze</groupId> <artifactId>demo</artifactId> <version>0.0.1-SNAPSHOT</version> <name>demo</name> <description>Demo project for Spring Boot</description> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-thymeleaf</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.0.0</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>1.5.9.RELEASE</version> </dependency> <dependency> <groupId>com.didispace</groupId> <artifactId>spring-boot-starter-swagger</artifactId> <version>1.1.0.RELEASE</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.11</version> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.4</version> </dependency> <!-- 分页插件 --> <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper-spring-boot-starter</artifactId> <version>1.2.5</version> </dependency> <!-- druid数据库连接池 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.9</version> </dependency> <!--tomcat--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> <!--<version>1.2.4.RELEASE</version>--> </dependency> <!--fastjson--> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.50</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> <finalName>blaze</finalName> </build> </project>
构建demo目录结构
application.properties改成application.yml格式的配置文件
server: port: 8080 spring: datasource: name: mysql_test type: com.alibaba.druid.pool.DruidDataSource #druid相关配置 druid: #监控统计拦截的filters filters: stat driver-class-name: com.mysql.jdbc.Driver #基本属性 url: jdbc:mysql://localhost:3306/blaze_test?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC username: root password: root #配置连接池 初始化大小/最小/最大 initial-size: 1 min-idle: 1 max-active: 20 #获取连接等待超时时间 max-wait: 60000 #间隔多久进行一次检测，检测需要关闭的空闲连接 time-between-eviction-runs-millis: 60000 #一个连接在池中最小生存的时间 min-evictable-idle-time-millis: 300000 validation-query: SELECT 'x' test-while-idle: true test-on-borrow: false test-on-return: false #打开PSCache，并指定每个连接上PSCache的大小。oracle设为true，mysql设为false。分库分表较多推荐设置为false pool-prepared-statements: false max-pool-prepared-statement-per-connection-size: 20 #redis相关配置 host把端口加进去(详见RedisConfig的jedisConnectionFactory) redis: database: 0 host: 193.168.10.102:6379 port: 6379 password: timeout: 500 pool: max-idle: 8 max-wait: -1 max-active: 8 min-idle: 0 #mybatis: # mapper-locations: classpath:mapper/*.xml # type-aliases-package: com.blaze.model #pagehelper pagehelper: helperDialect: mysql reasonable: true supportMethodsArguments: true params: count=countSql returnPageInfo: check #swagger swagger: title: spring-boot-starter-swagger description: Starter for swagger 2.x version: 1.1.0.RELEASE license: Apache License, Version 2.0 license-url: https://www.apache.org/licenses/LICENSE-2.0.html terms-of-service-url: https://github.com/github-sun/Funs base-package: com.blaze.demo contact: name: blaze email: 279790279@qq.com
UserDomain.java
package com.blaze.demo.model; import java.io.Serializable; /** * create by zy 2019/5/30 10:35 * TODO */ public class UserDomain implements Serializable { private int id; private String userId; private String userName; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getUserId() { return userId; } public void setUserId(String userId) { this.userId = userId; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } }
UserDao.java
package com.blaze.demo.dao; import com.blaze.demo.model.UserDomain; import org.apache.ibatis.annotations.Insert; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Options; import org.apache.ibatis.annotations.Select; import org.springframework.transaction.annotation.Transactional; import java.util.List; /** * create by zy 2019/5/30 10:28 * TODO */ @Mapper public interface UserDao { //新增user 如果已经存在相同的userName 则不插入数据 @Insert("INSERT INTO tb_user(id,user_id,user_name) SELECT #{id}, #{userId},#{userName} FROM DUAL WHERE NOT EXISTS (SELECT user_name FROM tb_user WHERE user_name=#{userName})") @Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "id") @Transactional int insert(UserDomain record); //查询 @Select("SELECT id, user_id as userId, user_name as userName FROM tb_user") List<UserDomain> selectUsers(); }
UserService.java
package com.blaze.demo.service; import com.blaze.demo.model.UserDomain; import com.github.pagehelper.PageInfo; /** * create by zy 2019/5/30 10:30 * TODO */ public interface UserService { /** * 新增user * @param user * @return */ int addUser(UserDomain user); /** * 分页查询userList * @param pageNum * @param pageSize * @return */ PageInfo<UserDomain> findAllUser(int pageNum, int pageSize); }
UserServiceImpl.java
package com.blaze.demo.service.impl; import com.blaze.demo.dao.UserDao; import com.blaze.demo.model.UserDomain; import com.blaze.demo.service.UserService; import com.github.pagehelper.PageHelper; import com.github.pagehelper.PageInfo; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.List; /** * create by zy 2019/5/30 10:28 * TODO */ @Service public class UserServiceImpl implements UserService { @Autowired private UserDao userDao;//这里会报错，但是并不会影响 @Override public int addUser(UserDomain user) { return userDao.insert(user); } /* * 这个方法中用到了我们开头配置依赖的分页插件pagehelper * 很简单，只需要在service层传入参数，然后将参数传递给一个插件的一个静态方法即可； * pageNum 开始页数 * pageSize 每页显示的数据条数 * */ @Override public PageInfo<UserDomain> findAllUser(int pageNum, int pageSize) { //将参数传给这个方法就可以实现物理分页了，非常简单。 PageHelper.startPage(pageNum, pageSize); List<UserDomain> userDomains = userDao.selectUsers(); PageInfo result = new PageInfo(userDomains); return result; } }
UserController.java
package com.blaze.demo.controller; import com.blaze.demo.model.UserDomain; import com.blaze.demo.service.UserService; import io.swagger.annotations.Api; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; /** * create by zy 2019/5/30 10:28 * TODO * CrossOrigin 允许跨域访问 */ @Api(value = "", tags = {"用户管理接口"}) @CrossOrigin(maxAge = 3600, origins = "*") @RestController @RequestMapping(value = "/user") public class UserController { private final Logger logger = LoggerFactory.getLogger(this.getClass()); @Autowired private UserService userService; @ResponseBody @PostMapping("/add") public int addUser(UserDomain user) { logger.info("-------------blaze add user--------------"); return userService.addUser(user); } @ResponseBody @GetMapping("/all") public Object findAllUser( @RequestParam(name = "pageNum", required = false, defaultValue = "1") int pageNum, @RequestParam(name = "pageSize", required = false, defaultValue = "10") int pageSize) { logger.info("-------------blaze select user--------------"); return userService.findAllUser(pageNum, pageSize); } }
DemoApplication.java
package com.blaze.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cache.annotation.EnableCaching; import org.springframework.scheduling.annotation.EnableScheduling; import springfox.documentation.swagger2.annotations.EnableSwagger2; /** * 此处加上@EnableSwagger2注解 才能使用swagger * 加上@EnableCaching 使用redis */ @SpringBootApplication @EnableSwagger2 @EnableCaching public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }
集成使用redis
配置在application.yml中
RedisConfig.java
package com.blaze.demo.config; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Value; import org.springframework.cache.CacheManager; import org.springframework.cache.annotation.CachingConfigurerSupport; import org.springframework.cache.annotation.EnableCaching; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.env.MapPropertySource; import org.springframework.data.redis.cache.RedisCacheManager; import org.springframework.data.redis.connection.RedisClusterConfiguration; import org.springframework.data.redis.connection.jedis.JedisConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer; import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer; import org.springframework.data.redis.serializer.StringRedisSerializer; import redis.clients.jedis.JedisPoolConfig; import java.util.HashMap; import java.util.Map; /** * create by zy 2019/5/30 14:19 * TODO */ @Configuration @EnableCaching public class RedisConfig extends CachingConfigurerSupport { private Logger logger = LoggerFactory.getLogger(this.getClass()); @Value("${spring.redis.host}") private String host; @Value("${spring.redis.port}") private int port; @Value("${spring.redis.timeout}") private int timeout; @Value("${spring.redis.pool.max-idle}") private int maxIdle; @Value("${spring.redis.pool.max-wait}") private long maxWaitMillis; @Value("${spring.redis.password}") private String password; @Bean public JedisPoolConfig getJedisPoolConfig() { JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); jedisPoolConfig.setMaxIdle(maxIdle); jedisPoolConfig.setMaxWaitMillis(maxWaitMillis); return jedisPoolConfig; } @Bean public JedisConnectionFactory jedisConnectionFactory() { if (host.split(",").length == 1) { //单机版 logger.info("-----------------blaze redis 单机版-------------------------"); JedisConnectionFactory factory = new JedisConnectionFactory(); factory.setHostName(host.split(":")[0]); factory.setPort(Integer.valueOf(host.split(":")[1])); factory.setPassword(password); factory.setTimeout(timeout); factory.setPoolConfig(getJedisPoolConfig()); return factory; } else { //集群 logger.info("-----------------blaze redis 集群版-------------------------"); JedisConnectionFactory jcf = new JedisConnectionFactory(getClusterConfiguration()); jcf.setPoolConfig(getJedisPoolConfig()); jcf.setPassword(password); //集群的密码认证 return jcf; } } @Bean public CacheManager cacheManager(RedisTemplate redisTemplate) { logger.info("===cacheManager successed"); RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate); //设置缓存过期时间 redisCacheManager.setDefaultExpiration(1800);//秒 return redisCacheManager; } @Bean(name = "redisTemplate") public RedisTemplate<String, Object> getRedisTemplate() { logger.info("===redisTemplate successed"); RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer()); redisTemplate.setHashKeySerializer(new StringRedisSerializer()); redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer(Object.class)); redisTemplate.setConnectionFactory(jedisConnectionFactory()); return redisTemplate; } @Bean public RedisClusterConfiguration getClusterConfiguration() { if (host.split(",").length > 1) { //如果是host是集群模式的才进行以下操作 Map<String, Object> source = new HashMap<String, Object>(); source.put("spring.redis.cluster.nodes", host); source.put("spring.redis.cluster.timeout", timeout); //source.put("spring.redis.cluster.max-redirects", redirects); source.put("spring.redis.cluster.password", password); return new RedisClusterConfiguration(new MapPropertySource("RedisClusterConfiguration", source)); } else { return null; } } }
RedisCommon.java
package com.blaze.demo.utils; import org.springframework.data.redis.core.RedisTemplate; import javax.annotation.Resource; import java.util.List; import java.util.Set; import java.util.concurrent.TimeUnit; /** * create by zy 2019/5/30 14:33 * TODO 随便写的 有点简单粗暴 凑合看吧 */ public class RedisCommon { @Resource private RedisTemplate redisTemplate; public RedisCommon(RedisTemplate client) { this.redisTemplate = client; } /** * 值类型 put * * @param key * @param val * @return */ public boolean setObjectVal(String key, Object val) { try { redisTemplate.boundValueOps(key).set(val); return true; } catch (Exception e) { return false; } } /** * 值类型put 带过期时间 * * @param key * @param val * @param expries * @param timeUnit * @return */ public boolean setObjectValExpries(String key, Object val, int expries, TimeUnit timeUnit) { try { redisTemplate.boundValueOps(key).set(val, expries, timeUnit); return true; } catch (Exception e) { return false; } } /** * 值类型get * * @param key * @return */ public Object getObjectVal(String key) { try { return redisTemplate.boundValueOps(key).get(); } catch (Exception e) { return null; } } /** * set类型put * * @param key * @param val * @return */ public boolean setSetVal(String key, Set val) { try { for (Object o : val) { redisTemplate.boundSetOps(key).add(o); } return true; } catch (Exception e) { return false; } } /** * set类型get * * @param key * @return */ public Set getSetVal(String key) { try { return redisTemplate.boundSetOps(key).members(); } catch (Exception e) { return null; } } /** * 删除set中的一项 * * @param key * @param opt * @return */ public boolean removeSetOpt(String key, Object opt) { try { redisTemplate.boundSetOps(key).remove(opt); return true; } catch (Exception e) { return false; } } public boolean setLeftListVal(String key, List<Object> val) { try { for (Object o : val) { redisTemplate.boundListOps(key).leftPush(o); } return true; } catch (Exception e) { return false; } } public boolean setRightListVal(String key, List<Object> val) { try { for (Object o : val) { redisTemplate.boundListOps(key).rightPush(o); } return true; } catch (Exception e) { return false; } } public List getListVal(String key, int start, int end) { try { return redisTemplate.boundListOps(key).range(start, end); } catch (Exception e) { return null; } } public Object getListVal(String key, int index) { try { return redisTemplate.boundListOps(key).index(index); } catch (Exception e) { return null; } } public boolean removeListOpt(String key, int index, Object opt) { try { redisTemplate.boundListOps(key).remove(index, opt); return true; } catch (Exception e) { return false; } } //hash类型的不写了 /** * 删除 * * @param key * @return */ public boolean delete(String key) { try { redisTemplate.delete(key); return true; } catch (Exception e) { return false; } } }
测试
前提：确保配置文件中配置的mysql和redis都正常
因为使用了swagger 可直接运行 访问http://localhost:8080/swagger-ui.html 测试
也可直接访问对应的url http://localhost:8080/user/all
测试redis
package com.blaze.demo; import com.alibaba.fastjson.JSON; import com.blaze.demo.model.UserDomain; import com.blaze.demo.utils.RedisCommon; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.test.context.junit4.SpringRunner; import javax.annotation.Resource; import java.util.concurrent.TimeUnit; @RunWith(SpringRunner.class) @SpringBootTest public class DemoApplicationTests { @Resource private RedisTemplate redisTemplate; @Test public void blaze() { RedisCommon redisUtil = new RedisCommon(redisTemplate); redisUtil.setObjectValExpries("blaze", "123456", 30, TimeUnit.SECONDS); System.out.println(redisUtil.getObjectVal("blaze")); UserDomain user = new UserDomain(); user.setId(1); user.setUserId("2333"); user.setUserName("blazeZzz"); redisUtil.setObjectValExpries("blazeZzz", JSON.toJSONString(user), 30, TimeUnit.SECONDS); System.out.println(redisUtil.getObjectVal("blazeZzz")); } }
结果
集成ES
引入依赖
<dependency> <groupId>org.elasticsearch</groupId> <artifactId>elasticsearch</artifactId> <version>6.0.0</version> </dependency> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>transport</artifactId> <version>6.0.0</version> </dependency>
API类
package com.blaze.demo.es; import org.elasticsearch.client.transport.TransportClient; import org.elasticsearch.common.settings.Settings; import org.elasticsearch.common.transport.TransportAddress; import org.elasticsearch.transport.client.PreBuiltTransportClient; import java.net.InetAddress; /** * create by zy 2019/6/5 10:52 * TODO 获取client */ public class ESClient { //private EsClient client = new EsClient(); TransportClient client = null; public ESClient() { try { client = new PreBuiltTransportClient(Settings.builder().put("cluster.name", "myes").build()) .addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.44.81"), 9300)) .addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.44.82"), 9300)); } catch (Exception ex) { client.close(); } finally { } } public TransportClient getConnection() { if (client == null) { synchronized (ESClient.class) { if (client == null) { new ESClient(); } } } return client; } }
package com.blaze.demo.es; import com.alibaba.fastjson.JSON; import com.blaze.demo.model.UserBaseInfo; import org.elasticsearch.action.ActionListener; import org.elasticsearch.action.bulk.BulkRequestBuilder; import org.elasticsearch.action.bulk.BulkResponse; import org.elasticsearch.action.delete.DeleteResponse; import org.elasticsearch.action.get.GetResponse; import org.elasticsearch.action.index.IndexResponse; import org.elasticsearch.client.transport.TransportClient; import org.elasticsearch.cluster.node.DiscoveryNode; import org.elasticsearch.common.xcontent.XContentFactory; import org.elasticsearch.common.xcontent.XContentType; import org.elasticsearch.index.query.QueryBuilders; import org.elasticsearch.index.reindex.BulkByScrollResponse; import org.elasticsearch.index.reindex.DeleteByQueryAction; import java.util.List; /** * create by zy 2019/6/5 11:18 * TODO */ public class ESUserApi { ESClient client = new ESClient(); private IndexResponse indexResponse; private DeleteResponse deleteResponse; public String testInfo() { List<DiscoveryNode> list = client.getConnection().connectedNodes(); String result = ""; for (DiscoveryNode node : list) { result += node.getHostAddress() + "|"; } return result; } public void index(UserBaseInfo user) { TransportClient connection = client.getConnection(); indexResponse = connection.prepareIndex("user", "baseinfo") .setSource(JSON.toJSON(user), XContentType.JSON) .get(); connection.close(); } /** * 单个添加 * * @param user * @return */ public boolean indexOne(UserBaseInfo user) { TransportClient connection = client.getConnection(); try { indexResponse = connection.prepareIndex("user", "baseinfo") .setSource(new XContentFactory().jsonBuilder() .startObject() .field("id", user.getId()) .field("name", user.getName()) .field("age", user.getAge()) .field("sex", user.getSex()) .field("address", user.getAddress()) .endObject()) .get(); return true; } catch (Exception e) { return false; } finally { connection.close(); } } /** * 批量添加 * * @param list * @return */ public boolean indexList(List<UserBaseInfo> list) { TransportClient connection = client.getConnection(); try { BulkRequestBuilder bulk = client.getConnection().prepareBulk(); for (UserBaseInfo user : list) { bulk.add(connection.prepareIndex("user", "baseinfo") .setSource(new XContentFactory().jsonBuilder() .startObject() .field("id", user.getId()) .field("name", user.getName()) .field("age", user.getAge()) .field("sex", user.getSex()) .field("address", user.getAddress()) .endObject())); } BulkResponse bulkResponse = bulk.get(); return true; } catch (Exception e) { return false; } finally { connection.close(); } } /** * 根据id删除 * * @param id * @return */ public boolean delById(String id) { TransportClient connection = client.getConnection(); deleteResponse = connection.prepareDelete("user", "baseinfo", id).get(); return true; } /** * 根据userid删除 * * @param id * @return */ public boolean delete(String id) { TransportClient connection = client.getConnection(); try { DeleteByQueryAction.INSTANCE.newRequestBuilder(connection) .filter(QueryBuilders.matchQuery("id", id)) .source("user") .execute(new ActionListener<BulkByScrollResponse>() { public void onResponse(BulkByScrollResponse response) { long deleted = response.getDeleted(); System.out.println("---------------blaze-----------" + deleted); } public void onFailure(Exception e) { System.out.println("---------------blaze delete fail-----------"); } }); return true; } catch (Exception e) { System.out.println("---------------blaze delete error-----------"); return false; } finally { connection.close(); } } /** * 根据id获取user * @param id * @return */ public UserBaseInfo queryById(String id) { TransportClient connection = client.getConnection(); try { GetResponse response = connection.prepareGet("user", "baseinfo", id).get(); String json = response.getSourceAsString(); UserBaseInfo userBaseInfo = JSON.parseObject(json, UserBaseInfo.class); return userBaseInfo; } catch (Exception e) { return null; } finally { connection.close(); } } }
测试
@Test public void testEs() { UserBaseInfo user = new UserBaseInfo(); user.setAddress("北京"); user.setAge("20"); user.setId("1"); user.setName("张学友"); user.setSex("男"); ESUserApi api = new ESUserApi(); api.indexOne(user); } @Test public void esDel() { ESUserApi api = new ESUserApi(); //String result = api.delById("s6fZJGsBkpzU0bPvXPBt"); //System.out.println(result); api.delete("1"); } @Test public void esQuery(){ ESUserApi api = new ESUserApi(); UserBaseInfo user = api.queryById("23H7JGsBdD3MzWimrdrK"); System.out.println(user.toString()); }
以上。
