spring 注入:
1,配置文件注入
(一)bean
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="realm" ref="authenticationRealm" />
<!-- <property name="cacheManager" ref="shiroCacheManager" /> -->
</bean>
<bean id="authenticationRealm" class="com.esteel.common.AuthenticationRealm">
<property name="authorizationCacheName" value="authorization" />//这部分也是字符串注入
</bean>
(二)字符串注入
<bean id="myShiroFilterFactory" class="com.esteel.common.MyShiroFilterFactory">
<property name="filterChainDefinitions">
<value>
/admin/ = anon
/index/ = anon
/index = anon
/login = anon
/logout = logout
/getRandomValidateCode = anon
/verifyCode = anon
/admin/** = anon
/main**=authc
/ui/info**=authc
/ui/listUser**=authc,perms[admin:manage]
/dwzIndex**=authc,perms[admin:manage]
</value>
</property>
</bean>
public class MyShiroFilterFactory {
private static Logger logger = LoggerFactory
.getLogger(MyShiroFilterFactory.class);
private String filterChainDefinitions;
/**
* 通过filterChainDefinitions对默认的url过滤定义
*
* @param filterChainDefinitions 默认的url过滤定义
*/
public void setFilterChainDefinitions(String filterChainDefinitions) {
this.filterChainDefinitions = filterChainDefinitions;
}
bean注入的一种高级用法,用了泛型即注入的对象及其类型是spring自动调用实现他的被注入对象的getObject得到的类型对象
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager" />
<property name="loginUrl" value="/ui/login.jsp" />
<property name="successUrl" value="/ui/dwzIndex.jsp" />
<property name="unauthorizedUrl" value="/ui/accessDenied.jsp" />
//这里注入的对象不是ChainDefinitionSectionMetaSour而是他实现的getObject方法返回的对象Ini.Section,他实际上就是一个map,不知知道这点会导致注入失败,Section实现map接口
所以直接注给map即可
<property name="filterChainDefinitionMap" ref="chainDefinitionSectionMetaSource" /> //spring 动态注入
<property name="filters">
<map>
<entry key="authc" value-ref="authenticationFilter" />
<entry key="role" value-ref="roleAuthorizationFilter" />
</map>
</property>
</bean>
<bean id="chainDefinitionSectionMetaSource" class="com.esteel.common.ChainDefinitionSectionMetaSource">
public class ShiroFilterFactoryBean
/* */ implements FactoryBean, BeanPostProcessor
/* */ {
/* */
/* */ private Map<String, String> filterChainDefinitionMap;
public Map<String, String> getFilterChainDefinitionMap()
/* */ {
/* 295 */ return this.filterChainDefinitionMap;
/* */ }
public void setFilterChainDefinitionMap(Map<String, String> filterChainDefinitionMap)
/* */ {
/* 308 */ this.filterChainDefinitionMap = filterChainDefinitionMap;
/* */ }
}
package com.esteel.common;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.shiro.config.Ini;
import org.apache.shiro.config.Ini.Section;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import com.esteel.system.bean.OpmMenuitem;
import com.esteel.system.bean.OpmMenuitemlimit;
import com.esteel.system.beanVo.OpmRolelimitVo;
import com.esteel.system.service.OpmMenuitemService;
import com.esteel.system.service.OpmMenuitemlimitService;
import com.esteel.system.service.OpmRolelimitService;
public class ChainDefinitionSectionMetaSource implements FactoryBean<Ini.Section>{
// @Autowired
// private ResourceDao resourceDao;
@Autowired
private OpmRolelimitService opmRolelimitService;
@Autowired
private OpmMenuitemlimitService opmMenuitemlimitService;
@Autowired
private OpmMenuitemService opmMenuitemService;
private String filterChainDefinitions;
/**
* 默认premission字符串
*/
public static final String PREMISSION_STRING="perms[\"{0}\"]";
public Section getObject() throws BeansException {
//获取所有Resource
List<OpmRolelimitVo> list =new ArrayList<OpmRolelimitVo>();
List<OpmRolelimitVo> listAll =new ArrayList<OpmRolelimitVo>();
list= opmRolelimitService.getRoleLimtContro();
OpmMenuitem item = new OpmMenuitem();
List<OpmMenuitem> items =opmMenuitemService.getMenuItems(item);
OpmMenuitemlimit opmMenuitemlimit = new OpmMenuitemlimit();
List<OpmMenuitemlimit> opmMenuitemlimits =opmMenuitemlimitService.getOpmMenuitemlimit(opmMenuitemlimit);
List<OpmMenuitem> itemsb =new ArrayList<OpmMenuitem>();
List<OpmMenuitemlimit> opmMenuitemlimitsb =new ArrayList<OpmMenuitemlimit>();
Set<String> itms= new HashSet<String>();
Set<String> itmls= new HashSet<String>();
for (Iterator<OpmRolelimitVo> it1 = list.iterator(); it1.hasNext();) {
OpmRolelimitVo resource = it1.next();
if(resource.getMenuitemid()!=null){
//如果不为空值添加到section中
if(!"".equals(resource.getMenuitemid()) &&!"".equals(resource.getMenuitemid())) {
itms.add(resource.getMenuitemid());
}
}
if(resource.getMenuitemlimitid()!=null&&(resource.getMenuitemlimitid()!=null)&&!"".equals(resource.getMenuitemlimitid())){
itmls.add(resource.getMenuitemlimitid());
}
}
for(String im :itms){
OpmMenuitem o = new OpmMenuitem();
o.setId(im);
itemsb.add(o);
}
for(String im :itmls){
OpmMenuitemlimit o = new OpmMenuitemlimit();
o.setId(im);
opmMenuitemlimitsb.add(o);
}
items.removeAll(itemsb);
opmMenuitemlimits.removeAll(opmMenuitemlimitsb);
Ini ini = new Ini();
//加载默认的url
ini.load(filterChainDefinitions);
Ini.Section section = ini.getSection(Ini.DEFAULT_SECTION_NAME);
//循环Resource的url,逐个添加到section中。section就是filterChainDefinitionMap,
//里面的键就是链接URL,值就是存在什么条件才能访问该链接
Map<String,Set<String>> mapr = new HashMap<String,Set<String>>();
Set<String> roleIds=null;
Set<String> mlroleIds=null;
if(list!=null&&list.size()>0){
for(OpmRolelimitVo r :list){
roleIds=new HashSet<String>();
mlroleIds=new HashSet<String>();
for (Iterator<OpmRolelimitVo> it = list.iterator(); it.hasNext();) {
OpmRolelimitVo resource = it.next();
if(r.getMenuitemid().equals(resource.getMenuitemid())){
//如果不为空值添加到section中
if(!"".equals(resource.getMenuitemid()) &&!"".equals(resource.getMenuitemid())) {
roleIds.add(resource.getRoleid());
}
}
if(r.getMenuitemlimitid()!=null&&resource.getMenuitemlimitid()!=null&&(r.getMenuitemlimitid().equals(resource.getMenuitemlimitid()))){
mlroleIds.add(resource.getRoleid());
}
}
//这里可以直接转set用section
mapr.put(r.getMuri(), roleIds);
mapr.put(r.getMluri(), mlroleIds);
}
}
StringBuffer au=null;
String st="";
for(Map.Entry<String, Set<String>> en:mapr.entrySet()){
au = new StringBuffer();
au.append("authc,role[");
for(String a :en.getValue()){
au.append("\""+a+"\",");
}
String strau=au.substring(0,au.lastIndexOf(","));
strau+="]";
st+=en.getKey()+">>>>"+strau+"\n";
section.put(en.getKey()+"**",strau);
}
// section.put("dwzIndex", MessageFormat.format(PREMISSION_STRING, "authc,perms[admin:manage]"));格式错了
//
// section.put(resource.getMenuitemid(), MessageFormat.format(PREMISSION_STRING, resource.getMenuitemid()));
// section.put("/system/tbBasBed/list**","authc,perms[admin:manage]");
System.out.println(st);
for(OpmMenuitem i: items){
section.put(i.getUri()+"**","authc,role[tempr]");
}
for(OpmMenuitemlimit i: opmMenuitemlimits){
section.put(i.getUri()+"**","authc,role[tempr]");
}
return section;
}
/**
* 通过filterChainDefinitions对默认的url过滤定义
*
* @param filterChainDefinitions 默认的url过滤定义
*/
public void setFilterChainDefinitions(String filterChainDefinitions) {
this.filterChainDefinitions = filterChainDefinitions;
}
public Class<?> getObjectType() {
return this.getClass();
}
public boolean isSingleton() {
return false;
}
}
2注解注入:
public class AuthenticationRealm extends AuthorizingRealm {
@Autowired
private OpmUserService opmUserService;
@Autowired
private OpmUserRoleService opmUserRoleService;
@Autowired
private OpmRolelimitService opmRolelimitService;}
3,构造方法注入:
注意:注入接口的时候注解将实现类赋值给接口
相关推荐
这种方式是通过实现特定的接口,由Spring在运行时动态调用接口方法注入依赖。Spring没有内置的接口注入机制,但可以通过实现`InitializingBean`或`DisposableBean`接口来自定义初始化和销毁逻辑。例如: ```java ...
本文将详细探讨Spring中的两种主要注入方式:构造器注入和setter注入,以及它们各自的特点和适用场景。 首先,让我们理解什么是依赖注入(Dependency Injection,简称DI)。在传统的编程模式中,一个类通常会直接...
spring注入配置文件,使用注解注入的
我们在开发过程中经常会发生spring注入错误或失败的情况,其实Web服务器端在Action、dao、service包之内是很容易实现的,在这些包之外实现spring注入就不容易了,总是出错,其实根本原因是无法获得相应的spring上...
Spring 框架是 Java 开发中非常重要的一个组件,它提供了一种强大的依赖注入(Dependency Injection,简称 DI)机制,使得对象之间的依赖关系可以通过配置文件或者注解来管理,而不是硬编码在类的内部。这有助于提高...
Spring框架的依赖注入(Dependency Injection,简称DI)是其核心特性之一,它使得对象之间的关系在运行时由Spring容器管理,而不是硬编码在类内部。这样可以提高代码的可测试性和可维护性,因为对象的依赖关系变得松...
2. AOP:Spring的AOP框架用于在运行时动态地修改程序的行为,比如在依赖注入时,AOP代理可以在目标对象的方法调用前后插入相应的行为,如检查依赖是否已注入,或者在注入过程中执行一些额外的操作。 此外,Spring还...
在本篇文章中,我们将深入探讨Spring注入原理,特别是注解方式的实现,帮助你更好地理解和掌握这一技术。 ### 1. 依赖注入(Dependency Injection) 依赖注入是Spring的核心特性,它允许我们解耦组件间的依赖关系...
在Spring框架中,依赖注入(Dependency Injection,简称DI)是一种重要的设计模式,它使得对象间的依赖关系得以解耦,提高了代码的可测试性和可维护性。Spring提供了多种注入方式,包括set注入、构造注入和自动注入...
Spring依赖注入是Spring框架的核心特性之一,它极大地简化了Java应用程序的开发,使得对象之间的依赖关系得以解耦,提高了代码的可测试性和可维护性。本文将深入探讨Spring依赖注入的概念、工作原理以及如何在实际...
使用spring的依赖注入,来实现servlet中注入dao层
Spring Boot 中的几种注入方法 在 Spring Boot 中,注入是一种非常重要的机制,用于将 bean 对象注入到其他 bean 对象中,以便实现松耦合和高内聚的设计目标。下面我们将对 Spring Boot 中的几种注入方法进行详细的...
**Spring Ioc 注入详解** Spring 框架的核心特性之一就是依赖注入(Dependency Injection,简称DI),也常被称为控制反转(Inversion of Control,IoC)。它是一种设计模式,可以减少代码之间的耦合,提高系统的可...
下面将详细介绍这三种方式以及Spring的自动注入机制。 1. **基于XML的Bean定义**: 在XML配置中,我们通常在`applicationContext.xml`文件中定义Bean。例如,对于`Student`和`Teacher`类,我们分别创建`bean`标签...
综上所述,Spring注入文件的写法涉及了数据源、Hibernate集成、事务管理和DAO的声明及配置。通过这种方式,Spring能够提供一个灵活且强大的基础设施,支持数据库操作和事务管理,同时保持代码的整洁和模块化。
SpringBoot 应用动态编译 Java 源码并注入 Spring 容器,实现动态修改接口和抽象类的实现。注意,项目以 Jar 包形式启动时要在命令行引入 tools.jar 的包,IDEA下可直接调试。 基于接口、抽象类实现不停机动态调整...
在Spring框架中,依赖注入(Dependency Injection,简称DI)是一种重要的设计模式,它使得对象之间的耦合度降低,提高了代码的可测试性和可维护性。本篇将详细讲解如何使用构造器注入作为Spring依赖注入的一种方式,...
Spring bean 一般通过配置文件和注解进行加载,如果要实现jar或class文件,动态实现spring bean 的动态加载,并通过UrlClassLoader完成jar和class文件的加载。可以实现jar的热替换。spring的bean动态加载则需要对...
**Spring 依赖注入 (DI) 与 Bean** Spring 框架的核心特性之一就是依赖注入(Dependency Injection,简称 DI),这是一种设计模式,它允许我们控制组件之间的耦合,而不是让组件自行创建它们所依赖的对象。这有助于...
### Spring框架中的属性值注入详解 #### 一、Spring框架简介 Spring框架是一个开源的Java平台,用于构建企业级应用程序。它提供了全面的基础架构支持,包括依赖注入(Dependency Injection, DI)、面向切面编程...