Java AclAuthorizationStrategy类代码示例

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
@Override
public void insertAce(int atIndexLocation, Permission permission, Sid sid, boolean granting) throws NotFoundException {
    aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
    Assert.notNull(permission, "Permission required");
    Assert.notNull(sid, "Sid required");
    if (atIndexLocation < 0) {
        throw new NotFoundException("atIndexLocation must be greater than or equal to zero");
    }
    if (atIndexLocation > this.aces.size()) {
        throw new NotFoundException("atIndexLocation must be less than or equal to the size of the AccessControlEntry collection");
    }

    AccessControlEntryImpl ace = new AccessControlEntryImpl.Builder()
            .acl(this)
            .sid(TenantSid.from(sid))
            .permission(permission)
            .granting(granting).build();

    synchronized (aces) {
        this.aces.add(atIndexLocation, ace);
    }
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
public MongodbAclService(AclEntryRepository aclEntryRepository,
		AclObjectIdentityRepository objectIdentityRepository,
		AclSidRepository sidRepository,
		AclClassService aclClassService,
		AclCache aclCache,
		AclAuthorizationStrategy aclAuthorizationStrategy,
		PermissionFactory permissionFactory,
		PermissionGrantingStrategy grantingStrategy) {
	super();
	this.aclEntryRepository = aclEntryRepository;
	this.objectIdentityRepository = objectIdentityRepository;
	this.sidRepository = sidRepository;
	this.aclClassService = aclClassService;
	this.aclCache = aclCache;
	this.aclAuthorizationStrategy = aclAuthorizationStrategy;
	this.permissionFactory = permissionFactory;
	this.grantingStrategy = grantingStrategy;
	
	this.fieldAces.setAccessible(true);
	this.fieldAcl.setAccessible(true);
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
@SuppressWarnings("deprecation")
@Before
public void initBeans() {
       AclAuthorizationStrategy authorizationStrategy = new AclAuthorizationStrategyImpl(
       		new SimpleGrantedAuthority("ROLE_ADMINISTRATOR"),
       		new SimpleGrantedAuthority("ROLE_ADMINISTRATOR"),
       		new SimpleGrantedAuthority("ROLE_ADMINISTRATOR")
       		);
       cache = new EhCacheBasedAclCache(getCache());
       mongodbMutableAclService = new MongodbMutableAclService(
			aclEntryRepository, 
			objectIdentityRepository, 
			aclSidRepository,
			new SimpleCacheAclClassService(aclClassRepository), 
			cache, 
			authorizationStrategy, 
			new DefaultPermissionFactory(), 
			new DefaultPermissionGrantingStrategy(new ConsoleAuditLogger()));
	seedMongodbData();
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
@SuppressWarnings("deprecation")
@Before
public void initBeans() {
       AclAuthorizationStrategy authorizationStrategy = new AclAuthorizationStrategyImpl(new SimpleGrantedAuthority("ROLE_ADMINISTRATOR"));
       EhCacheBasedAclCache cache = new EhCacheBasedAclCache(getCache());
	mongodbAclService = new MongodbAclService(
			aclEntryRepository, 
			objectIdentityRepository, 
			aclSidRepository,
			new SimpleCacheAclClassService(aclClassRepository), 
			cache, 
			authorizationStrategy, 
			new DefaultPermissionFactory(), 
			new DefaultPermissionGrantingStrategy(new ConsoleAuditLogger()));
	seedMongodbData();
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
/**
 * Constructor
 * 
 * @param graphDatabaseService - Graph Database Service
 * @param aclCache - Acl Cache
 * @param aclAuthorizationStrategy - Acl Authorization Strategy
 * @param permissionGrantingStrategy - Permission Granting Strategy
 */
public Neo4jLookupStrategy(GraphDatabaseService graphDatabaseService,
		AclCache aclCache,
		AclAuthorizationStrategy aclAuthorizationStrategy,
		PermissionGrantingStrategy permissionGrantingStrategy) {
	Assert.notNull(aclCache, "AclCache required");
	Assert.notNull(aclAuthorizationStrategy,
			"AclAuthorizationStrategy required");
	Assert.notNull(permissionGrantingStrategy,
			"permissionGrantingStrategy required");
	this.aclCache = aclCache;
	this.aclAuthorizationStrategy = aclAuthorizationStrategy;
	this.permissionGrantingStrategy = permissionGrantingStrategy;
	this.neo4jTemplate = new Neo4jTemplate(graphDatabaseService);
	fieldAces.setAccessible(true);
	fieldAcl.setAccessible(true);
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
public BasicLookupStrategy(DataSource dataSource, AclCache aclCache,
        AclAuthorizationStrategy aclAuthorizationStrategy, PermissionGrantingStrategy grantingStrategy) {
    Assert.notNull(dataSource, "DataSource required");
    Assert.notNull(aclCache, "AclCache required");
    Assert.notNull(aclAuthorizationStrategy, "AclAuthorizationStrategy required");
    Assert.notNull(grantingStrategy, "grantingStrategy required");
    jdbcTemplate = new JdbcTemplate(dataSource);
    this.aclCache = aclCache;
    this.aclAuthorizationStrategy = aclAuthorizationStrategy;
    this.grantingStrategy = grantingStrategy;
    fieldAces.setAccessible(true);
    fieldAcl.setAccessible(true);

}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
@Override
public void deleteAce(int aceIndex) throws NotFoundException {
    aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
    verifyAceIndexExists(aceIndex);

    synchronized (aces) {
        this.aces.remove(aceIndex);
    }
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
@Override
public void updateAce(int aceIndex, Permission permission)
    throws NotFoundException {
    aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
    verifyAceIndexExists(aceIndex);

    synchronized (aces) {
        AccessControlEntryImpl ace = (AccessControlEntryImpl) aces.get(aceIndex);
        aces.set(aceIndex, new AccessControlEntryImpl.Builder().from(ace).permission(permission).build());
    }
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
@Override
public void updateAuditing(int aceIndex, boolean auditSuccess, boolean auditFailure) {
    aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_AUDITING);
    verifyAceIndexExists(aceIndex);

    synchronized (aces) {
        AccessControlEntryImpl ace = (AccessControlEntryImpl) aces.get(aceIndex);
        aces.set(aceIndex, new AccessControlEntryImpl.Builder().from(ace)
                .auditSuccess(auditSuccess)
                .auditFailure(auditFailure)
                .build());
    }
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
public MongoAclService(DB db, AclCache aclCache, PermissionGrantingStrategy permissionGrantingStrategy,
        AclAuthorizationStrategy aclAuthorizationStrategy) {
    this.db = db;
    this.aclCache = aclCache;
    this.permissionGrantingStrategy = permissionGrantingStrategy;
    this.aclAuthorizationStrategy = aclAuthorizationStrategy;
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
public MongodbMutableAclService(AclEntryRepository aclEntryRepository,
		AclObjectIdentityRepository objectIdentityRepository,
		AclSidRepository aclSidRepository,
		AclClassService aclClassService,
		AclCache aclCache,
		AclAuthorizationStrategy aclAuthorizationStrategy,
		PermissionFactory permissionFactory,
		PermissionGrantingStrategy grantingStrategy) {
	super(aclEntryRepository, objectIdentityRepository, aclSidRepository, aclClassService,
			aclCache, aclAuthorizationStrategy,
			permissionFactory, grantingStrategy);
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
/**
 * Constructs a new <code>CassandraAclService</code> object.
 * 
 * @param aclRepository the {@link CassandraAclRepository} to use for access to the database.
 * @param aclCache the {@link AclCache} to use (can be <code>null</code>).
 * @param grantingStrategy the {@link PermissionGrantingStrategy} to use when creating {@link Acl} objects.
 * @param aclAuthorizationStrategy the {@link AclAuthorizationStrategy} to use when creating {@link Acl} objects.
 * @param permissionFactory the {@link PermissionFactory} to use when creating {@link AccessControlEntry} objects.
 */
public CassandraAclService(CassandraAclRepository aclRepository, AclCache aclCache, PermissionGrantingStrategy grantingStrategy,
		AclAuthorizationStrategy aclAuthorizationStrategy, PermissionFactory permissionFactory) {
	this.aclRepository = aclRepository;
	this.aclCache = aclCache;
	this.grantingStrategy = grantingStrategy;
	this.aclAuthorizationStrategy = aclAuthorizationStrategy;
	this.permissionFactory = permissionFactory;
	this.fieldAces.setAccessible(true);
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
public AclAuthorizationStrategy getAclAuthorizationStrategy() {
    return aclAuthorizationStrategy;
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
public void setAclAuthorizationStrategy(AclAuthorizationStrategy aclAuthorizationStrategy) {
    this.aclAuthorizationStrategy = aclAuthorizationStrategy;
}
 

import org.springframework.security.acls.domain.AclAuthorizationStrategy; //导入依赖的package包/类
@Override
public void setEntriesInheriting(boolean entriesInheriting) {
    aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
    this.entriesInheriting = entriesInheriting;
}