Spring MVC + Redis 使用Maven

最新推荐文章于 2021-08-21 09:35:06 发布
最新推荐文章于 2021-08-21 09:35:06 发布
阅读量1.7k 收藏
点赞数
分类专栏： Spring MVC Maven 软件开发维度 文章标签： Spring MVC Redis Maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_21578557/article/details/53692062
版权

按照我的思路去配，已跑通！！！
 
import  java.io.Serializable;
 
public  abstract  class  BaseModel  implements  Serializable{
 
}

　　

1
 
import  java.util.Map;
 
import  org.springframework.web.servlet.ModelAndView;
 
public  class  BaseMultiController {
     protected  ModelAndView toView( final  String url, final  Map<String,Object> map)
     {  
         ModelAndView  view =  new  ModelAndView(url);
         return  view;
     }
}

 

1
 
import  java.io.Serializable;
 
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.data.redis.core.RedisTemplate;
import  org.springframework.data.redis.serializer.RedisSerializer;
 
public  abstract  class  RedisGeneratorDao<K  extends  Serializable, V  extends  Serializable>  {
   
   @Autowired
   protected  RedisTemplate<K,V> redisTemplate ;
 
   /**
    * 设置redisTemplate
    * @param redisTemplate the redisTemplate to set
    */ 
   public  void  setRedisTemplate(RedisTemplate<K, V> redisTemplate) { 
     this .redisTemplate = redisTemplate; 
   } 
     
   /**
    * 获取 RedisSerializer
    * <br>------------------------------<br>
    */ 
   protected  RedisSerializer<String> getRedisSerializer() { 
     return  redisTemplate.getStringSerializer(); 
   }
 
}

 

1
 
import  java.util.HashMap;
import  java.util.Map;
 
import  javax.servlet.http.HttpServletRequest;
import  javax.servlet.http.HttpServletResponse;
 
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.stereotype.Controller;
import  org.springframework.web.bind.annotation.ModelAttribute;
import  org.springframework.web.bind.annotation.PathVariable;
import  org.springframework.web.bind.annotation.RequestMapping;
import  org.springframework.web.bind.annotation.RequestMethod;
import  org.springframework.web.servlet.ModelAndView;
 
import  com.pudp.bae.base.BaseMultiController;
import  com.pudp.bae.model.Member;
import  com.pudp.bae.service.MemberService;
 
@Controller
@RequestMapping (value =  "/member" )
public  class  MemberController  extends  BaseMultiController {
 
     @Autowired
     private  MemberService memberService;
 
     public  void  setMemberService(MemberService memberService) {
         this .memberService = memberService;
     }
 
     @RequestMapping (value = {  "/add" ,  "/add.html"  }, method = { RequestMethod.GET })
     public  ModelAndView add(HttpServletRequest request,
             HttpServletResponse response) {
         Map<String, Object> map =  new  HashMap<String, Object>();
         Member member =  new  Member();
         member.setId( "1" );
         member.setNickname( "guoxiaoming" );
         this .memberService.add(member);
         
         return  toView( "add" , map);
     }
 
     @RequestMapping (value = {  "/add" ,  "/add.html"  }, method = { RequestMethod.POST })
     public  ModelAndView addMember(HttpServletRequest request,
             HttpServletResponse response,
             @ModelAttribute ( "member" ) Member member) {
         Map<String, Object> map =  new  HashMap<String, Object>();
         System.out.println(member);
         map.put( "message" ,  "成功添加数据到库,"  + member);
         this .memberService.add(member);
         return  toView( "message" , map);
     }
 
     @RequestMapping (value = {  "/{id:\\d+}/query" ,  "/{id:\\d+}/query.html"  }, method = {
             RequestMethod.GET, RequestMethod.POST })
     public  ModelAndView queryMember(HttpServletRequest request,
             HttpServletResponse response,  @PathVariable ( "id" ) String id) {
         Map<String, Object> map =  new  HashMap<String, Object>();
         System.out.println(id);
         Member member =  this .memberService.get(id);
         if  ( null  != member) {
             map.put( "message" ,  "查询Id="  + id +  "的用户名为:"  + member.getNickname());
         }  else  {
             map.put( "message" ,  "没有查询到与Id="  + id +  "相关的数据" );
         }
         return  toView( "message" , map);
     }
 
     @RequestMapping (value = {  "/{id:\\d+}/delete" ,  "/{id:\\d+}/delete.html"  }, method = {
             RequestMethod.GET, RequestMethod.POST })
     public  ModelAndView deleteMember(HttpServletRequest request,
             HttpServletResponse response,  @PathVariable ( "id" ) String id) {
         Map<String, Object> map =  new  HashMap<String, Object>();
         try  {
             this .memberService.delete(id);
             map.put( "message" ,  "删除Id为"  + id +  "的用户成功." );
         }  catch  (Exception e) {
             e.printStackTrace();
             map.put( "message" ,  "删除Id为"  + id +  "的用户失败, "  + e.getMessage());
         }
         return  toView( "message" , map);
     }
 
}

　　

 
 
import  java.util.List;
 
import  com.pudp.bae.model.Member;
 
public  interface  MemberDao {
     boolean  add(Member member);
 
     abstract  boolean  add(List<Member> list);
 
     void  delete(String key);
 
     Member get(String keyId);
     
}

　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
package  com.pudp.bae.dao.redis;
 
import  java.util.ArrayList;
import  java.util.List;
 
import  org.springframework.dao.DataAccessException;
import  org.springframework.data.redis.connection.RedisConnection;
import  org.springframework.data.redis.core.RedisCallback;
import  org.springframework.data.redis.serializer.RedisSerializer;
import  org.springframework.stereotype.Repository;
import  org.springframework.util.Assert;
 
import  com.pudp.bae.base.RedisGeneratorDao;
import  com.pudp.bae.model.Member;
 
 
@Repository (value= "memberDao" )
public  class  MemberDaoImpl  extends  RedisGeneratorDao<String,Member>  implements  MemberDao{
   
   /**
    * 添加对象
    */
   @Override
   public  boolean  add( final  Member member) { 
     boolean  result = redisTemplate.execute( new  RedisCallback<Boolean>() { 
       public  Boolean doInRedis(RedisConnection connection) 
           throws  DataAccessException { 
         RedisSerializer<String> serializer = getRedisSerializer(); 
         byte [] key  = serializer.serialize(member.getId()); 
         byte [] name = serializer.serialize(member.getNickname()); 
         return  connection.setNX(key, name); 
       } 
     }); 
     return  result; 
   } 
 
   /**
    * 添加集合
    */
   @Override
   public  boolean  add( final  List<Member> list) {
     Assert.notEmpty(list); 
     boolean  result = redisTemplate.execute( new  RedisCallback<Boolean>() { 
       public  Boolean doInRedis(RedisConnection connection) 
           throws  DataAccessException { 
         RedisSerializer<String> serializer = getRedisSerializer(); 
         for  (Member member : list) { 
           byte [] key  = serializer.serialize(member.getId()); 
           byte [] name = serializer.serialize(member.getNickname()); 
           connection.setNX(key, name); 
         } 
         return  true ; 
       } 
     },  false ,  true ); 
     return  result;
   } 
   
   /**
    * 删除对象 ,依赖key
    */
   @Override
   public  void  delete(String key) { 
     List<String> list =  new  ArrayList<String>(); 
     list.add(key); 
     delete(list); 
   } 
   
   /**
    * 删除集合 ,依赖key集合
    */
   public  void  delete(List<String> keys) { 
     redisTemplate.delete(keys); 
   } 
   
   /**
    * 修改对象
    */
   public  boolean  update( final  Member member) { 
     String key = member.getId(); 
     if  (get(key) ==  null ) { 
       throw  new  NullPointerException( "数据行不存在, key = "  + key); 
     } 
     boolean  result = redisTemplate.execute( new  RedisCallback<Boolean>() { 
       public  Boolean doInRedis(RedisConnection connection) 
           throws  DataAccessException { 
         RedisSerializer<String> serializer = getRedisSerializer(); 
         byte [] key  = serializer.serialize(member.getId()); 
         byte [] name = serializer.serialize(member.getNickname()); 
         connection.set(key, name); 
         return  true ; 
       } 
     }); 
     return  result; 
   } 
   
   /**
    * 根据key获取对象
    */
   @Override
   public  Member get( final  String keyId) { 
     Member result = redisTemplate.execute( new  RedisCallback<Member>() { 
       public  Member doInRedis(RedisConnection connection) 
           throws  DataAccessException { 
         RedisSerializer<String> serializer = getRedisSerializer(); 
         byte [] key = serializer.serialize(keyId); 
         byte [] value = connection.get(key); 
         if  (value ==  null ) { 
           return  null ; 
         } 
         String nickname = serializer.deserialize(value); 
         return  new  Member(keyId, nickname); 
       } 
     }); 
     return  result; 
   } 
 
}

 
 
import  com.pudp.bae.base.BaseModel;
 
public  class  Member  extends  BaseModel{
  
   private  static  final  long  serialVersionUID = -1959528436584592183L;
   private  String id;
   private  String nickname;
   
   public  Member(){}
   
   public  Member(String id, String nickname){
     this .setId(id);
     this .setNickname(nickname);
   }
   
   public  String getId() {
     return  id;
   }
   
   public  void  setId(String id) {
     this .id = id;
   }
   
   public  String getNickname() {
     return  nickname;
   }
   
   public  void  setNickname(String nickname) {
     this .nickname = nickname;
   }
   
}

 

 
 
import  javax.annotation.Resource;
 
import  com.pudp.bae.dao.redis.MemberDao;
import  com.pudp.bae.model.Member;
 
public  class  MemberService {
      
      @Resource (name= "memberDao" )
      private  MemberDao memberDao;
      
      public  void  setMemberDao(MemberDao memberDao)
      {
         this .memberDao = memberDao;
      }
       
      public  void  add(Member member){
          memberDao.add(member);
      }
      
      public  void  delete(String id){
          memberDao.delete(id);
      }
      
      public  Member get(String id)
      {
          return  memberDao.get(id);
      }
}

redis-context.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<beans    xmlns= "http://www.springframework.org/schema/beans"
        xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p= "http://www.springframework.org/schema/p"
        xmlns:tx= "http://www.springframework.org/schema/tx"
        xmlns:context= "http://www.springframework.org/schema/context"
        xsi:schemaLocation="
       http: //www.springframework.org/schema/beans
       http: //www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http: //www.springframework.org/schema/tx
       http: //www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http: //www.springframework.org/schema/context
       http: //www.springframework.org/schema/context/spring-context-3.0.xsd
          ">
   
   <!-- scanner redis properties  -->
   <context:property-placeholder location= "/WEB-INF/property/redis.properties"  />
   
   <bean id= "poolConfig"  class = "redis.clients.jedis.JedisPoolConfig" > 
     <property name= "maxIdle"  value= "${redis.maxIdle}"  /> 
     <property name= "maxActive"  value= "${redis.maxActive}"  /> 
     <property name= "maxWait"  value= "${redis.maxWait}"  /> 
     <property name= "testOnBorrow"  value= "${redis.testOnBorrow}"  /> 
   </bean> 
     
   <bean id= "connectionFactory"  class = "org.springframework.data.redis.connection.jedis.JedisConnectionFactory" 
     p:host-name= "${redis.host}"
     p:port= "${redis.port}"
     p:password= "${redis.pass}" 
     p:pool-config-ref= "poolConfig" /> 
     
   <bean id= "redisTemplate"  class = "org.springframework.data.redis.core.StringRedisTemplate" > 
     <property name= "connectionFactory"    ref= "connectionFactory"  /> 
   </bean>  
    
</beans> 

 

spring-context.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?xml version= "1.0"  encoding= "UTF-8" ?>
<beans xmlns= "http://www.springframework.org/schema/beans"
     xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"  xmlns:p= "http://www.springframework.org/schema/p"
     xmlns:mvc= "http://www.springframework.org/schema/mvc"  xmlns:context= "http://www.springframework.org/schema/context"
     xmlns:util= "http://www.springframework.org/schema/util"
     xsi:schemaLocation="http: //www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
       http: //www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd 
       http: //www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd         
       http: //www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">
     
     
     <!-- 激活 @Controller 模式 -->
     <mvc:annotation-driven />
 
     
     <!-- 对包中的所有类进行扫描，以完成Bean创建和自动依赖注入的功能 需要更改 -->
     <context:component-scan base- package = "com.pudp.bae.*"  />
  
     <bean id= "memberService"  class = "com.pudp.bae.service.MemberService" />
     
     
     <!-- 引入同文件夹下的redis属性配置文件 -->
     < import  resource= "redis-context.xml" />
 
</beans>

spring-mvc.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?xml version= "1.0"  encoding= "UTF-8" ?>
<beans xmlns= "http://www.springframework.org/schema/beans"
      xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"
      xmlns:context= "http://www.springframework.org/schema/context"
      xmlns:mvc= "http://www.springframework.org/schema/mvc"
      xsi:schemaLocation="http: //www.springframework.org/schema/beans
          http: //www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http: //www.springframework.org/schema/context
          http: //www.springframework.org/schema/context/spring-context-3.0.xsd
          http: //www.springframework.org/schema/mvc
          http: //www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
          
  
<!-- 配置视图解析器，把控制器的逻辑视频映射为真正的视图 -->
<!-- /WEB-INF/jsp/start.jsp -->
<bean  class = "org.springframework.web.servlet.view.UrlBasedViewResolver" >
     <property name= "viewClass"  value= "org.springframework.web.servlet.view.JstlView" />
     <property name= "prefix"  value= "/WEB-INF/jsp/"  />
     <property name= "suffix"  value= ".jsp"  />
</bean>
 
</beans>

redis.properties

1
2
3
4
5
6
7
8
9
10
11
# Redis settings
#redis.host= 192.168 . 20.101
#redis.port= 6380
#redis.pass=foobared
redis.host= 127.0 . 0.1
redis.port= 6379
redis.pass=xx
redis.maxIdle= 300
redis.maxActive= 600
redis.maxWait= 1000
redis.testOnBorrow= true

 

web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?xml version= "1.0"  encoding= "UTF-8" ?>
<web-app version= "2.4"  aaxmlns= "http://java.sun.com/xml/ns/j2ee"
     aaxmlns:xsi= "w3.org/2001/XMLSchema-instance"
     aaxsi:schemaLocation= "http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" >
     <display-name>SpringMVCRedis</display-name>
     <listener>
         <listener- class >org.springframework.web.context.ContextLoaderListener
         </listener- class >
     </listener>
 
     <context-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>/WEB-INF/context/spring-context.xml</param-value>
     </context-param>
 
     <filter>
         <filter-name>SpringEncodingFilter</filter-name>
         <filter- class >org.springframework.web.filter.CharacterEncodingFilter
         </filter- class >
 
         <init-param>
             <param-name>encoding</param-name>
             <param-value>UTF- 8 </param-value>
         </init-param>
 
         <init-param>
             <param-name>forceEncoding</param-name>
             <param-value> true </param-value>
         </init-param>
     </filter>
 
     <filter-mapping>
         <filter-name>SpringEncodingFilter</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>
 
     <servlet>
         <servlet-name>mvc</servlet-name>
         <servlet- class >org.springframework.web.servlet.DispatcherServlet
         </servlet- class >
         <init-param>
             <param-name>contextConfigLocation</param-name>
             <param-value>/WEB-INF/context/spring-mvc.xml</param-value>
         </init-param>
         <load-on-startup> 2 </load-on-startup>
     </servlet>
 
     <servlet-mapping>
         <servlet-name>mvc</servlet-name>
         <url-pattern>/</url-pattern>
     </servlet-mapping>
 
     <welcome-file-list>
         <welcome-file>index.jsp</welcome-file>
     </welcome-file-list>
</web-app>

奔跑着的国风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC使用Redis
数据产品小lee
09-30 9082
前置： 1.下载Redis，启动Redis 2.使用idea内置Maven工具构建SpringMVC项目 参考链接：idea创建SpringMVC项目 本次目标：将对象序列化到Redis中，从Redis中取出。 先单元测试测试Service层，再启动应用测试Controller层。 idea创建maven项目。pom文件如下: &lt;?xml version="1.0" encoding="...
springmvc+redis哨兵搭建
lllllsssssddddd的博客
08-19 1037
springmvc+redis哨兵搭建
springmvc整合redis架构搭建实例
weixin_39403708的博客
08-26 160
1 原文 http://www.cnblogs.com/dennisit/p/3614521.html 2 3 新换环境,又有新东西可以学习了,哈皮! 抽空学习之余看了一下redis,个人对Springmvc的爱是忠贞不渝,所以整理了一下Springmvc整合redis的环境搭建.分享学习. 4 5 第一步 :...
Java中使用redis所需要的pom依赖
热门推荐
qq_41774226的博客
04-26 3万+
&lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artifactId&gt;jedis&lt;/artifactId&gt; &lt;version&gt;2.1.0&lt;/version&gt; &lt;/dependency&gt; &lt;depende
spring+maven 整合 redis
aSmart_Q的博客
06-03 428
1.通过pom.xml配置redis需要的包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> <dependency> <groupId>com.alibaba&...
使用maven简单搭建Spring mvc + redis缓存
05-31
本文将详细讲解如何使用Maven来简单搭建一个集成了Spring MVC和Redis缓存的项目。 首先，让我们从Maven开始。Maven是一个项目管理工具，它帮助开发者管理依赖、构建项目以及执行自动化测试。在创建新项目时，我们...
spring+springMVC+Mybatis+MYSQL+Redis+Maven项目整合源码
01-06
该项目是一个基于Spring、SpringMVC、Mybatis、MySQL、Redis和Maven的综合应用实例，旨在为初学者提供一个清晰易懂的学习平台。下面将详细解释这些技术组件及其在项目中的作用。 **Spring框架**： Spring是Java企业...
销售系统项目，spring+spring mvc+mybatis+dubbo+kafka+redis+maven.zip
08-20
【标题】"销售系统项目，spring+spring mvc+mybatis+dubbo+kafka+redis+maven.zip" 提供了一个综合的IT解决方案，涉及到的技术栈主要包括Spring、Spring MVC、MyBatis、Dubbo、Kafka、Redis以及Maven。这个项目采用...
一个基于SSMM（SpringMVC+ Spring + Mybatis + Redis + Maven）的练手Demo.zip
最新发布
06-07
本项目是一个基于 Spring MVC + Spring + Mybatis + Redis + Maven 的入门级(拥有完整的登录/注册逻辑)Demo，是在SSM-Demo项目的基础上修改、调整而来，主要涉及以下几项技术及知识点： 使用SpringMVC作MVC控制器；...
基于Springboot+Mybatis+ SpringMvc+springsecrity+Redis完整网站后台管理系统
10-31
项目描述 说明： spring security 全注解式的权限管理 动态配置权限，角色和资源，权限控制到...Springboot+Mybatis+ SpringMvc+springsecrity+Redis+bootstrap+jquery 数据库文件 压缩包内 jar包文件 maven搭建
SpringMVC+maven+redis集成示例
04-05
SpringMVC+maven+redis集成教程 http://blog.csdn.net/u012775558/article/details/68937298
maven+spring4+springmvc+redis实现分页
08-08
只要你的redis已经准备好即可。该项目需要maven依赖，请自行安装maven。然后把redis的链接地址改一下，用tomcat发布项目之后，进入项目:浏览器地址栏输入http://localhost:8080/ProjectRedis/mvc/news/query?current=1即可进入项目后面的current代表了分页【开始进入时没有数据，在首页进行添加即可】
SpringMVC+redis集成demo，超简单使用案例
04-19
SpringMVC+redis 简单案例，实现了简单的redis存取功能，以及springmvc的实例化功能，SpringMVC+redis 简单案例，实现了简单的redis存取功能，以及springmvc的实例化功能，SpringMVC+redis 简单案例，实现了简单的redis存取功能，以及springmvc的实例化功能
Maven+springMVC+mybatis+redis 项目搭建
Able
01-04 1611
pom.xml文件 <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/mave
Redis搭建：Maven+Spring+SpringMVC+Redis
qq_25635139的博客
01-23 358
下载之后直接解压得到以下目录结构 点击redis-server.exe即可启动Redis数据库 输出信息：启动成功、端口号、pid 即启动成功。   二、搭建开发环境 1&gt;搭建springmvc支持 &lt;!-- 搭建springmvc --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework&...
基于maven整合spring和redis
平凡之路
07-07 4276
1.导入别人的maven工程,报错The type org.springframework.core.NestedRuntimeException cannot be resolved. It is indirectly referenced from required .class files原因是:pom.xml缺少spring核心包的依赖感谢~~点击链接2.linux下启动redisnohup
redis结合springMVC配置和使用一
qililong88的博客
05-16 2687
redis结合springMVC配置和使用 JredisJedisRedis4J 我们以jedis为例（它是官方提供的唯一Redis Client For Java Provider） 引入redis后再application.xml中配置redis springMVC
springmvc配置使用redis
ITarmi的分享
08-21 2580
本篇文章不记录redis安装，redis在windows下安装也很简单。 首先下载安装redis,Windows下好像就是下载一个压缩包解压即可，内容如下 pom.xml文件引入redis依赖（注意redis和spring存在版本冲突，所以在你正确配置后仍然有问题就要考虑是不是版本冲突了） <dependency> <groupId>org.springframework.data</groupId> <arti
SpringMVC集成redis教程
u012775558的博客
03-31 6205
SpringMVC集成redis教程
使用SPRING构建J2EE框架实战指南
"基于SPRING构建J2EE框架，涵盖了 MAVEN工具使用、技术选型、JPA实现、spring-security安全管理和spring-session分布式会话管理，以及OAUTH2的实现" 在构建基于SPRING的J2EE框架时，首先需要理解J2EE的分层架构。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值