Always use 'this.' when accessing fields

Apply an Eclipse cleanup rules to ensure that fields are always accessed
using `this.`. This aligns with the style used by Spring Framework and
helps users quickly see the difference between a local and member
variable.

Issue gh-8945

acl/src/main/java/org/springframework/security/acls/AclEntryVoter.java

@@ -135,7 +135,7 @@ public class AclEntryVoter extends AbstractAclVoter {
 	 * which will be the domain object used for ACL evaluation
 	 */
 	protected String getInternalMethod() {
-		return internalMethod;
+		return this.internalMethod;
 	}
 
 	public void setInternalMethod(String internalMethod) {
@@ -143,7 +143,7 @@ public class AclEntryVoter extends AbstractAclVoter {
 	}
 
 	protected String getProcessConfigAttribute() {
-		return processConfigAttribute;
+		return this.processConfigAttribute;
 	}
 
 	public void setObjectIdentityRetrievalStrategy(ObjectIdentityRetrievalStrategy objectIdentityRetrievalStrategy) {
@@ -181,41 +181,41 @@ public class AclEntryVoter extends AbstractAclVoter {
 			}
 
 			// Evaluate if we are required to use an inner domain object
-			if (StringUtils.hasText(internalMethod)) {
+			if (StringUtils.hasText(this.internalMethod)) {
 				try {
 					Class<?> clazz = domainObject.getClass();
-					Method method = clazz.getMethod(internalMethod, new Class[0]);
+					Method method = clazz.getMethod(this.internalMethod, new Class[0]);
 					domainObject = method.invoke(domainObject);
 				}
 				catch (NoSuchMethodException nsme) {
 					throw new AuthorizationServiceException("Object of class '" + domainObject.getClass()
-							+ "' does not provide the requested internalMethod: " + internalMethod);
+							+ "' does not provide the requested internalMethod: " + this.internalMethod);
 				}
 				catch (IllegalAccessException iae) {
 					logger.debug("IllegalAccessException", iae);
 
 					throw new AuthorizationServiceException(
-							"Problem invoking internalMethod: " + internalMethod + " for object: " + domainObject);
+							"Problem invoking internalMethod: " + this.internalMethod + " for object: " + domainObject);
 				}
 				catch (InvocationTargetException ite) {
 					logger.debug("InvocationTargetException", ite);
 
 					throw new AuthorizationServiceException(
-							"Problem invoking internalMethod: " + internalMethod + " for object: " + domainObject);
+							"Problem invoking internalMethod: " + this.internalMethod + " for object: " + domainObject);
 				}
 			}
 
 			// Obtain the OID applicable to the domain object
-			ObjectIdentity objectIdentity = objectIdentityRetrievalStrategy.getObjectIdentity(domainObject);
+			ObjectIdentity objectIdentity = this.objectIdentityRetrievalStrategy.getObjectIdentity(domainObject);
 
 			// Obtain the SIDs applicable to the principal
-			List<Sid> sids = sidRetrievalStrategy.getSids(authentication);
+			List<Sid> sids = this.sidRetrievalStrategy.getSids(authentication);
 
 			Acl acl;
 
 			try {
 				// Lookup only ACLs for SIDs we're interested in
-				acl = aclService.readAclById(objectIdentity, sids);
+				acl = this.aclService.readAclById(objectIdentity, sids);
 			}
 			catch (NotFoundException nfe) {
 				if (logger.isDebugEnabled()) {
@@ -226,7 +226,7 @@ public class AclEntryVoter extends AbstractAclVoter {
 			}
 
 			try {
-				if (acl.isGranted(requirePermission, sids, false)) {
+				if (acl.isGranted(this.requirePermission, sids, false)) {
 					if (logger.isDebugEnabled()) {
 						logger.debug("Voting to grant access");
 					}

acl/src/main/java/org/springframework/security/acls/AclPermissionCacheOptimizer.java

@@ -63,17 +63,17 @@ public class AclPermissionCacheOptimizer implements PermissionCacheOptimizer {
 			if (domainObject == null) {
 				continue;
 			}
-			ObjectIdentity oid = oidRetrievalStrategy.getObjectIdentity(domainObject);
+			ObjectIdentity oid = this.oidRetrievalStrategy.getObjectIdentity(domainObject);
 			oidsToCache.add(oid);
 		}
 
-		List<Sid> sids = sidRetrievalStrategy.getSids(authentication);
+		List<Sid> sids = this.sidRetrievalStrategy.getSids(authentication);
 
-		if (logger.isDebugEnabled()) {
-			logger.debug("Eagerly loading Acls for " + oidsToCache.size() + " objects");
+		if (this.logger.isDebugEnabled()) {
+			this.logger.debug("Eagerly loading Acls for " + oidsToCache.size() + " objects");
 		}
 
-		aclService.readAclsById(oidsToCache, sids);
+		this.aclService.readAclsById(oidsToCache, sids);
 	}
 
 	public void setObjectIdentityRetrievalStrategy(ObjectIdentityRetrievalStrategy objectIdentityRetrievalStrategy) {

acl/src/main/java/org/springframework/security/acls/AclPermissionEvaluator.java

@@ -75,49 +75,49 @@ public class AclPermissionEvaluator implements PermissionEvaluator {
 			return false;
 		}
 
-		ObjectIdentity objectIdentity = objectIdentityRetrievalStrategy.getObjectIdentity(domainObject);
+		ObjectIdentity objectIdentity = this.objectIdentityRetrievalStrategy.getObjectIdentity(domainObject);
 
 		return checkPermission(authentication, objectIdentity, permission);
 	}
 
 	public boolean hasPermission(Authentication authentication, Serializable targetId, String targetType,
 			Object permission) {
-		ObjectIdentity objectIdentity = objectIdentityGenerator.createObjectIdentity(targetId, targetType);
+		ObjectIdentity objectIdentity = this.objectIdentityGenerator.createObjectIdentity(targetId, targetType);
 
 		return checkPermission(authentication, objectIdentity, permission);
 	}
 
 	private boolean checkPermission(Authentication authentication, ObjectIdentity oid, Object permission) {
 		// Obtain the SIDs applicable to the principal
-		List<Sid> sids = sidRetrievalStrategy.getSids(authentication);
+		List<Sid> sids = this.sidRetrievalStrategy.getSids(authentication);
 		List<Permission> requiredPermission = resolvePermission(permission);
 
-		final boolean debug = logger.isDebugEnabled();
+		final boolean debug = this.logger.isDebugEnabled();
 
 		if (debug) {
-			logger.debug("Checking permission '" + permission + "' for object '" + oid + "'");
+			this.logger.debug("Checking permission '" + permission + "' for object '" + oid + "'");
 		}
 
 		try {
 			// Lookup only ACLs for SIDs we're interested in
-			Acl acl = aclService.readAclById(oid, sids);
+			Acl acl = this.aclService.readAclById(oid, sids);
 
 			if (acl.isGranted(requiredPermission, sids, false)) {
 				if (debug) {
-					logger.debug("Access is granted");
+					this.logger.debug("Access is granted");
 				}
 
 				return true;
 			}
 
 			if (debug) {
-				logger.debug("Returning false - ACLs returned, but insufficient permissions for this principal");
+				this.logger.debug("Returning false - ACLs returned, but insufficient permissions for this principal");
 			}
 
 		}
 		catch (NotFoundException nfe) {
 			if (debug) {
-				logger.debug("Returning false - no ACLs apply for this principal");
+				this.logger.debug("Returning false - no ACLs apply for this principal");
 			}
 		}
 
@@ -127,7 +127,7 @@ public class AclPermissionEvaluator implements PermissionEvaluator {
 
 	List<Permission> resolvePermission(Object permission) {
 		if (permission instanceof Integer) {
-			return Arrays.asList(permissionFactory.buildFromMask((Integer) permission));
+			return Arrays.asList(this.permissionFactory.buildFromMask((Integer) permission));
 		}
 
 		if (permission instanceof Permission) {
@@ -143,10 +143,10 @@ public class AclPermissionEvaluator implements PermissionEvaluator {
 			Permission p;
 
 			try {
-				p = permissionFactory.buildFromName(permString);
+				p = this.permissionFactory.buildFromName(permString);
 			}
 			catch (IllegalArgumentException notfound) {
-				p = permissionFactory.buildFromName(permString.toUpperCase(Locale.ENGLISH));
+				p = this.permissionFactory.buildFromName(permString.toUpperCase(Locale.ENGLISH));
 			}
 
 			if (p != null) {

acl/src/main/java/org/springframework/security/acls/afterinvocation/AbstractAclProvider.java

@@ -68,21 +68,21 @@ public abstract class AbstractAclProvider implements AfterInvocationProvider {
 	}
 
 	protected Class<?> getProcessDomainObjectClass() {
-		return processDomainObjectClass;
+		return this.processDomainObjectClass;
 	}
 
 	protected boolean hasPermission(Authentication authentication, Object domainObject) {
 		// Obtain the OID applicable to the domain object
-		ObjectIdentity objectIdentity = objectIdentityRetrievalStrategy.getObjectIdentity(domainObject);
+		ObjectIdentity objectIdentity = this.objectIdentityRetrievalStrategy.getObjectIdentity(domainObject);
 
 		// Obtain the SIDs applicable to the principal
-		List<Sid> sids = sidRetrievalStrategy.getSids(authentication);
+		List<Sid> sids = this.sidRetrievalStrategy.getSids(authentication);
 
 		try {
 			// Lookup only ACLs for SIDs we're interested in
-			Acl acl = aclService.readAclById(objectIdentity, sids);
+			Acl acl = this.aclService.readAclById(objectIdentity, sids);
 
-			return acl.isGranted(requirePermission, sids, false);
+			return acl.isGranted(this.requirePermission, sids, false);
 		}
 		catch (NotFoundException ignore) {
 			return false;
@@ -110,7 +110,7 @@ public abstract class AbstractAclProvider implements AfterInvocationProvider {
 	}
 
 	public boolean supports(ConfigAttribute attribute) {
-		return processConfigAttribute.equals(attribute.getAttribute());
+		return this.processConfigAttribute.equals(attribute.getAttribute());
 	}
 
 	/**

acl/src/main/java/org/springframework/security/acls/afterinvocation/AclEntryAfterInvocationProvider.java

@@ -103,7 +103,7 @@ public class AclEntryAfterInvocationProvider extends AbstractAclProvider impleme
 
 			logger.debug("Denying access");
 
-			throw new AccessDeniedException(messages.getMessage("AclEntryAfterInvocationProvider.noPermission",
+			throw new AccessDeniedException(this.messages.getMessage("AclEntryAfterInvocationProvider.noPermission",
 					new Object[] { authentication.getName(), returnedObject },
 					"Authentication {0} has NO permissions to the domain object {1}"));
 		}

acl/src/main/java/org/springframework/security/acls/afterinvocation/ArrayFilterer.java

@@ -45,7 +45,7 @@ class ArrayFilterer<T> implements Filterer<T> {
 		// Collect the removed objects to a HashSet so that
 		// it is fast to lookup them when a filtered array
 		// is constructed.
-		removeList = new HashSet<>();
+		this.removeList = new HashSet<>();
 	}
 
 	/**
@@ -55,14 +55,14 @@ class ArrayFilterer<T> implements Filterer<T> {
 	@SuppressWarnings("unchecked")
 	public T[] getFilteredObject() {
 		// Recreate an array of same type and filter the removed objects.
-		int originalSize = list.length;
-		int sizeOfResultingList = originalSize - removeList.size();
-		T[] filtered = (T[]) Array.newInstance(list.getClass().getComponentType(), sizeOfResultingList);
+		int originalSize = this.list.length;
+		int sizeOfResultingList = originalSize - this.removeList.size();
+		T[] filtered = (T[]) Array.newInstance(this.list.getClass().getComponentType(), sizeOfResultingList);
 
-		for (int i = 0, j = 0; i < list.length; i++) {
-			T object = list[i];
+		for (int i = 0, j = 0; i < this.list.length; i++) {
+			T object = this.list[i];
 
-			if (!removeList.contains(object)) {
+			if (!this.removeList.contains(object)) {
 				filtered[j] = object;
 				j++;
 			}
@@ -85,14 +85,14 @@ class ArrayFilterer<T> implements Filterer<T> {
 			private int index = 0;
 
 			public boolean hasNext() {
-				return index < list.length;
+				return this.index < ArrayFilterer.this.list.length;
 			}
 
 			public T next() {
 				if (!hasNext()) {
 					throw new NoSuchElementException();
 				}
-				return list[index++];
+				return ArrayFilterer.this.list[this.index++];
 			}
 
 			public void remove() {
@@ -106,7 +106,7 @@ class ArrayFilterer<T> implements Filterer<T> {
 	 * @see org.springframework.security.acls.afterinvocation.Filterer#remove(java.lang.Object)
 	 */
 	public void remove(T object) {
-		removeList.add(object);
+		this.removeList.add(object);
 	}
 
 }

acl/src/main/java/org/springframework/security/acls/afterinvocation/CollectionFilterer.java

@@ -48,7 +48,7 @@ class CollectionFilterer<T> implements Filterer<T> {
 		// to the method may not necessarily be re-constructable (as
 		// the Collection(collection) constructor is not guaranteed and
 		// manually adding may lose sort order or other capabilities)
-		removeList = new HashSet<>();
+		this.removeList = new HashSet<>();
 	}
 
 	/**
@@ -57,20 +57,20 @@ class CollectionFilterer<T> implements Filterer<T> {
 	 */
 	public Object getFilteredObject() {
 		// Now the Iterator has ended, remove Objects from Collection
-		Iterator<T> removeIter = removeList.iterator();
+		Iterator<T> removeIter = this.removeList.iterator();
 
-		int originalSize = collection.size();
+		int originalSize = this.collection.size();
 
 		while (removeIter.hasNext()) {
-			collection.remove(removeIter.next());
+			this.collection.remove(removeIter.next());
 		}
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("Original collection contained " + originalSize + " elements; now contains "
-					+ collection.size() + " elements");
+					+ this.collection.size() + " elements");
 		}
 
-		return collection;
+		return this.collection;
 	}
 
 	/**
@@ -78,7 +78,7 @@ class CollectionFilterer<T> implements Filterer<T> {
 	 * @see org.springframework.security.acls.afterinvocation.Filterer#iterator()
 	 */
 	public Iterator<T> iterator() {
-		return collection.iterator();
+		return this.collection.iterator();
 	}
 
 	/**
@@ -86,7 +86,7 @@ class CollectionFilterer<T> implements Filterer<T> {
 	 * @see org.springframework.security.acls.afterinvocation.Filterer#remove(java.lang.Object)
 	 */
 	public void remove(T object) {
-		removeList.add(object);
+		this.removeList.add(object);
 	}
 
 }

acl/src/main/java/org/springframework/security/acls/domain/AbstractPermission.java

@@ -65,15 +65,15 @@ public abstract class AbstractPermission implements Permission {
 	}
 
 	public final int getMask() {
-		return mask;
+		return this.mask;
 	}
 
 	public String getPattern() {
-		return AclFormattingUtils.printBinary(mask, code);
+		return AclFormattingUtils.printBinary(this.mask, this.code);
 	}
 
 	public final String toString() {
-		return this.getClass().getSimpleName() + "[" + getPattern() + "=" + mask + "]";
+		return this.getClass().getSimpleName() + "[" + getPattern() + "=" + this.mask + "]";
 	}
 
 	public final int hashCode() {

acl/src/main/java/org/springframework/security/acls/domain/AccessControlEntryImpl.java

@@ -134,37 +134,37 @@ public class AccessControlEntryImpl implements AccessControlEntry, AuditableAcce
 
 	@Override
 	public Acl getAcl() {
-		return acl;
+		return this.acl;
 	}
 
 	@Override
 	public Serializable getId() {
-		return id;
+		return this.id;
 	}
 
 	@Override
 	public Permission getPermission() {
-		return permission;
+		return this.permission;
 	}
 
 	@Override
 	public Sid getSid() {
-		return sid;
+		return this.sid;
 	}
 
 	@Override
 	public boolean isAuditFailure() {
-		return auditFailure;
+		return this.auditFailure;
 	}
 
 	@Override
 	public boolean isAuditSuccess() {
-		return auditSuccess;
+		return this.auditSuccess;
 	}
 
 	@Override
 	public boolean isGranting() {
-		return granting;
+		return this.granting;
 	}
 
 	void setAuditFailure(boolean auditFailure) {

acl/src/main/java/org/springframework/security/acls/domain/AclAuthorizationStrategyImpl.java

@@ -68,12 +68,12 @@ public class AclAuthorizationStrategyImpl implements AclAuthorizationStrategy {
 		Assert.isTrue(auths != null && (auths.length == 3 || auths.length == 1),
 				"One or three GrantedAuthority instances required");
 		if (auths.length == 3) {
-			gaTakeOwnership = auths[0];
-			gaModifyAuditing = auths[1];
-			gaGeneralChanges = auths[2];
+			this.gaTakeOwnership = auths[0];
+			this.gaModifyAuditing = auths[1];
+			this.gaGeneralChanges = auths[2];
 		}
 		else {
-			gaTakeOwnership = gaModifyAuditing = gaGeneralChanges = auths[0];
+			this.gaTakeOwnership = this.gaModifyAuditing = this.gaGeneralChanges = auths[0];
 		}
 	}
 
@@ -117,7 +117,7 @@ public class AclAuthorizationStrategyImpl implements AclAuthorizationStrategy {
 		}
 
 		// Try to get permission via ACEs within the ACL
-		List<Sid> sids = sidRetrievalStrategy.getSids(authentication);
+		List<Sid> sids = this.sidRetrievalStrategy.getSids(authentication);
 
 		if (acl.isGranted(Arrays.asList(BasePermission.ADMINISTRATION), sids, false)) {
 			return;

acl/src/main/java/org/springframework/security/acls/domain/AclImpl.java

@@ -121,10 +121,10 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 
 	@Override
 	public void deleteAce(int aceIndex) throws NotFoundException {
-		aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
+		this.aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
 		verifyAceIndexExists(aceIndex);
 
-		synchronized (aces) {
+		synchronized (this.aces) {
 			this.aces.remove(aceIndex);
 		}
 	}
@@ -135,14 +135,14 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 		}
 		if (aceIndex >= this.aces.size()) {
 			throw new NotFoundException("aceIndex must refer to an index of the AccessControlEntry list. "
-					+ "List size is " + aces.size() + ", index was " + aceIndex);
+					+ "List size is " + this.aces.size() + ", index was " + aceIndex);
 		}
 	}
 
 	@Override
 	public void insertAce(int atIndexLocation, Permission permission, Sid sid, boolean granting)
 			throws NotFoundException {
-		aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
+		this.aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
 		Assert.notNull(permission, "Permission required");
 		Assert.notNull(sid, "Sid required");
 		if (atIndexLocation < 0) {
@@ -155,7 +155,7 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 
 		AccessControlEntryImpl ace = new AccessControlEntryImpl(null, this, sid, permission, granting, false, false);
 
-		synchronized (aces) {
+		synchronized (this.aces) {
 			this.aces.add(atIndexLocation, ace);
 		}
 	}
@@ -164,7 +164,7 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 	public List<AccessControlEntry> getEntries() {
 		// Can safely return AccessControlEntry directly, as they're immutable outside the
 		// ACL package
-		return new ArrayList<>(aces);
+		return new ArrayList<>(this.aces);
 	}
 
 	@Override
@@ -174,12 +174,12 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 
 	@Override
 	public ObjectIdentity getObjectIdentity() {
-		return objectIdentity;
+		return this.objectIdentity;
 	}
 
 	@Override
 	public boolean isEntriesInheriting() {
-		return entriesInheriting;
+		return this.entriesInheriting;
 	}
 
 	/**
@@ -198,7 +198,7 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 			throw new UnloadedSidException("ACL was not loaded for one or more SID");
 		}
 
-		return permissionGrantingStrategy.isGranted(this, permission, sids, administrativeMode);
+		return this.permissionGrantingStrategy.isGranted(this, permission, sids, administrativeMode);
 	}
 
 	@Override
@@ -213,7 +213,7 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 		for (Sid sid : sids) {
 			boolean found = false;
 
-			for (Sid loadedSid : loadedSids) {
+			for (Sid loadedSid : this.loadedSids) {
 				if (sid.equals(loadedSid)) {
 					// this SID is OK
 					found = true;
@@ -232,13 +232,13 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 
 	@Override
 	public void setEntriesInheriting(boolean entriesInheriting) {
-		aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
+		this.aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
 		this.entriesInheriting = entriesInheriting;
 	}
 
 	@Override
 	public void setOwner(Sid newOwner) {
-		aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_OWNERSHIP);
+		this.aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_OWNERSHIP);
 		Assert.notNull(newOwner, "Owner required");
 		this.owner = newOwner;
 	}
@@ -250,34 +250,34 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 
 	@Override
 	public void setParent(Acl newParent) {
-		aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
+		this.aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
 		Assert.isTrue(newParent == null || !newParent.equals(this), "Cannot be the parent of yourself");
 		this.parentAcl = newParent;
 	}
 
 	@Override
 	public Acl getParentAcl() {
-		return parentAcl;
+		return this.parentAcl;
 	}
 
 	@Override
 	public void updateAce(int aceIndex, Permission permission) throws NotFoundException {
-		aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
+		this.aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_GENERAL);
 		verifyAceIndexExists(aceIndex);
 
-		synchronized (aces) {
-			AccessControlEntryImpl ace = (AccessControlEntryImpl) aces.get(aceIndex);
+		synchronized (this.aces) {
+			AccessControlEntryImpl ace = (AccessControlEntryImpl) this.aces.get(aceIndex);
 			ace.setPermission(permission);
 		}
 	}
 
 	@Override
 	public void updateAuditing(int aceIndex, boolean auditSuccess, boolean auditFailure) {
-		aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_AUDITING);
+		this.aclAuthorizationStrategy.securityCheck(this, AclAuthorizationStrategy.CHANGE_AUDITING);
 		verifyAceIndexExists(aceIndex);
 
-		synchronized (aces) {
-			AccessControlEntryImpl ace = (AccessControlEntryImpl) aces.get(aceIndex);
+		synchronized (this.aces) {
+			AccessControlEntryImpl ace = (AccessControlEntryImpl) this.aces.get(aceIndex);
 			ace.setAuditSuccess(auditSuccess);
 			ace.setAuditFailure(auditFailure);
 		}
@@ -342,7 +342,7 @@ public class AclImpl implements Acl, MutableAcl, AuditableAcl, OwnershipAcl {
 
 		int count = 0;
 
-		for (AccessControlEntry ace : aces) {
+		for (AccessControlEntry ace : this.aces) {
 			count++;
 
 			if (count == 1) {

acl/src/main/java/org/springframework/security/acls/domain/DefaultPermissionFactory.java

@@ -103,21 +103,21 @@ public class DefaultPermissionFactory implements PermissionFactory {
 		Integer mask = perm.getMask();
 
 		// Ensure no existing Permission uses this integer or code
-		Assert.isTrue(!registeredPermissionsByInteger.containsKey(mask),
+		Assert.isTrue(!this.registeredPermissionsByInteger.containsKey(mask),
 				() -> "An existing Permission already provides mask " + mask);
-		Assert.isTrue(!registeredPermissionsByName.containsKey(permissionName),
+		Assert.isTrue(!this.registeredPermissionsByName.containsKey(permissionName),
 				() -> "An existing Permission already provides name '" + permissionName + "'");
 
 		// Register the new Permission
-		registeredPermissionsByInteger.put(mask, perm);
-		registeredPermissionsByName.put(permissionName, perm);
+		this.registeredPermissionsByInteger.put(mask, perm);
+		this.registeredPermissionsByName.put(permissionName, perm);
 	}
 
 	public Permission buildFromMask(int mask) {
-		if (registeredPermissionsByInteger.containsKey(mask)) {
+		if (this.registeredPermissionsByInteger.containsKey(mask)) {
 			// The requested mask has an exact match against a statically-defined
 			// Permission, so return it
-			return registeredPermissionsByInteger.get(mask);
+			return this.registeredPermissionsByInteger.get(mask);
 		}
 
 		// To get this far, we have to use a CumulativePermission
@@ -127,7 +127,7 @@ public class DefaultPermissionFactory implements PermissionFactory {
 			int permissionToCheck = 1 << i;
 
 			if ((mask & permissionToCheck) == permissionToCheck) {
-				Permission p = registeredPermissionsByInteger.get(permissionToCheck);
+				Permission p = this.registeredPermissionsByInteger.get(permissionToCheck);
 
 				if (p == null) {
 					throw new IllegalStateException(
@@ -141,7 +141,7 @@ public class DefaultPermissionFactory implements PermissionFactory {
 	}
 
 	public Permission buildFromName(String name) {
-		Permission p = registeredPermissionsByName.get(name);
+		Permission p = this.registeredPermissionsByName.get(name);
 
 		if (p == null) {
 			throw new IllegalArgumentException("Unknown permission '" + name + "'");

acl/src/main/java/org/springframework/security/acls/domain/DefaultPermissionGrantingStrategy.java

@@ -90,7 +90,7 @@ public class DefaultPermissionGrantingStrategy implements PermissionGrantingStra
 						if (ace.isGranting()) {
 							// Success
 							if (!administrativeMode) {
-								auditLogger.logIfNeeded(true, ace);
+								this.auditLogger.logIfNeeded(true, ace);
 							}
 
 							return true;
@@ -120,7 +120,7 @@ public class DefaultPermissionGrantingStrategy implements PermissionGrantingStra
 			// We found an ACE to reject the request at this point, as no
 			// other ACEs were found that granted a different permission
 			if (!administrativeMode) {
-				auditLogger.logIfNeeded(false, firstRejection);
+				this.auditLogger.logIfNeeded(false, firstRejection);
 			}
 
 			return false;

acl/src/main/java/org/springframework/security/acls/domain/EhCacheBasedAclCache.java

@@ -61,8 +61,8 @@ public class EhCacheBasedAclCache implements AclCache {
 		MutableAcl acl = getFromCache(pk);
 
 		if (acl != null) {
-			cache.remove(acl.getId());
-			cache.remove(acl.getObjectIdentity());
+			this.cache.remove(acl.getId());
+			this.cache.remove(acl.getObjectIdentity());
 		}
 	}
 
@@ -72,8 +72,8 @@ public class EhCacheBasedAclCache implements AclCache {
 		MutableAcl acl = getFromCache(objectIdentity);
 
 		if (acl != null) {
-			cache.remove(acl.getId());
-			cache.remove(acl.getObjectIdentity());
+			this.cache.remove(acl.getId());
+			this.cache.remove(acl.getObjectIdentity());
 		}
 	}
 
@@ -83,7 +83,7 @@ public class EhCacheBasedAclCache implements AclCache {
 		Element element = null;
 
 		try {
-			element = cache.get(objectIdentity);
+			element = this.cache.get(objectIdentity);
 		}
 		catch (CacheException ignored) {
 		}
@@ -101,7 +101,7 @@ public class EhCacheBasedAclCache implements AclCache {
 		Element element = null;
 
 		try {
-			element = cache.get(pk);
+			element = this.cache.get(pk);
 		}
 		catch (CacheException ignored) {
 		}
@@ -131,8 +131,8 @@ public class EhCacheBasedAclCache implements AclCache {
 			putInCache((MutableAcl) acl.getParentAcl());
 		}
 
-		cache.put(new Element(acl.getObjectIdentity(), acl));
-		cache.put(new Element(acl.getId(), acl));
+		this.cache.put(new Element(acl.getObjectIdentity(), acl));
+		this.cache.put(new Element(acl.getId(), acl));
 	}
 
 	private MutableAcl initializeTransientFields(MutableAcl value) {
@@ -148,7 +148,7 @@ public class EhCacheBasedAclCache implements AclCache {
 	}
 
 	public void clearCache() {
-		cache.removeAll();
+		this.cache.removeAll();
 	}
 
 }

acl/src/main/java/org/springframework/security/acls/domain/GrantedAuthoritySid.java

@@ -62,7 +62,7 @@ public class GrantedAuthoritySid implements Sid {
 	}
 
 	public String getGrantedAuthority() {
-		return grantedAuthority;
+		return this.grantedAuthority;
 	}
 
 	@Override

acl/src/main/java/org/springframework/security/acls/domain/ObjectIdentityImpl.java

@@ -69,7 +69,7 @@ public class ObjectIdentityImpl implements ObjectIdentity {
 		Assert.notNull(object, "object cannot be null");
 
 		Class<?> typeClass = ClassUtils.getUserClass(object.getClass());
-		type = typeClass.getName();
+		this.type = typeClass.getName();
 
 		Object result;
 
@@ -105,30 +105,30 @@ public class ObjectIdentityImpl implements ObjectIdentity {
 
 		ObjectIdentityImpl other = (ObjectIdentityImpl) arg0;
 
-		if (identifier instanceof Number && other.identifier instanceof Number) {
+		if (this.identifier instanceof Number && other.identifier instanceof Number) {
 			// Integers and Longs with same value should be considered equal
-			if (((Number) identifier).longValue() != ((Number) other.identifier).longValue()) {
+			if (((Number) this.identifier).longValue() != ((Number) other.identifier).longValue()) {
 				return false;
 			}
 		}
 		else {
 			// Use plain equality for other serializable types
-			if (!identifier.equals(other.identifier)) {
+			if (!this.identifier.equals(other.identifier)) {
 				return false;
 			}
 		}
 
-		return type.equals(other.type);
+		return this.type.equals(other.type);
 	}
 
 	@Override
 	public Serializable getIdentifier() {
-		return identifier;
+		return this.identifier;
 	}
 
 	@Override
 	public String getType() {
-		return type;
+		return this.type;
 	}
 
 	/**

acl/src/main/java/org/springframework/security/acls/domain/PrincipalSid.java

@@ -62,7 +62,7 @@ public class PrincipalSid implements Sid {
 	}
 
 	public String getPrincipal() {
-		return principal;
+		return this.principal;
 	}
 
 	@Override

acl/src/main/java/org/springframework/security/acls/domain/SidRetrievalStrategyImpl.java

@@ -52,7 +52,7 @@ public class SidRetrievalStrategyImpl implements SidRetrievalStrategy {
 	}
 
 	public List<Sid> getSids(Authentication authentication) {
-		Collection<? extends GrantedAuthority> authorities = roleHierarchy
+		Collection<? extends GrantedAuthority> authorities = this.roleHierarchy
 				.getReachableGrantedAuthorities(authentication.getAuthorities());
 		List<Sid> sids = new ArrayList<>(authorities.size() + 1);
 

acl/src/main/java/org/springframework/security/acls/domain/SpringCacheBasedAclCache.java

@@ -62,8 +62,8 @@ public class SpringCacheBasedAclCache implements AclCache {
 		MutableAcl acl = getFromCache(pk);
 
 		if (acl != null) {
-			cache.evict(acl.getId());
-			cache.evict(acl.getObjectIdentity());
+			this.cache.evict(acl.getId());
+			this.cache.evict(acl.getObjectIdentity());
 		}
 	}
 
@@ -73,8 +73,8 @@ public class SpringCacheBasedAclCache implements AclCache {
 		MutableAcl acl = getFromCache(objectIdentity);
 
 		if (acl != null) {
-			cache.evict(acl.getId());
-			cache.evict(acl.getObjectIdentity());
+			this.cache.evict(acl.getId());
+			this.cache.evict(acl.getObjectIdentity());
 		}
 	}
 
@@ -97,12 +97,12 @@ public class SpringCacheBasedAclCache implements AclCache {
 			putInCache((MutableAcl) acl.getParentAcl());
 		}
 
-		cache.put(acl.getObjectIdentity(), acl);
-		cache.put(acl.getId(), acl);
+		this.cache.put(acl.getObjectIdentity(), acl);
+		this.cache.put(acl.getId(), acl);
 	}
 
 	private MutableAcl getFromCache(Object key) {
-		Cache.ValueWrapper element = cache.get(key);
+		Cache.ValueWrapper element = this.cache.get(key);
 
 		if (element == null) {
 			return null;
@@ -124,7 +124,7 @@ public class SpringCacheBasedAclCache implements AclCache {
 	}
 
 	public void clearCache() {
-		cache.clear();
+		this.cache.clear();
 	}
 
 }

acl/src/main/java/org/springframework/security/acls/jdbc/AclClassIdUtils.java

@@ -109,11 +109,11 @@ class AclClassIdUtils {
 	}
 
 	private <T> boolean canConvertFromStringTo(Class<T> targetType) {
-		return conversionService.canConvert(String.class, targetType);
+		return this.conversionService.canConvert(String.class, targetType);
 	}
 
 	private <T extends Serializable> T convertFromStringTo(String identifier, Class<T> targetType) {
-		return conversionService.convert(identifier, targetType);
+		return this.conversionService.convert(identifier, targetType);
 	}
 
 	/**
@@ -128,8 +128,8 @@ class AclClassIdUtils {
 	 */
 	private Long convertToLong(Serializable identifier) {
 		Long idAsLong;
-		if (conversionService.canConvert(identifier.getClass(), Long.class)) {
-			idAsLong = conversionService.convert(identifier, Long.class);
+		if (this.conversionService.canConvert(identifier.getClass(), Long.class)) {
+			idAsLong = this.conversionService.convert(identifier, Long.class);
 		}
 		else {
 			idAsLong = Long.valueOf(identifier.toString());

acl/src/main/java/org/springframework/security/acls/jdbc/BasicLookupStrategy.java

@@ -156,21 +156,21 @@ public class BasicLookupStrategy implements LookupStrategy {
 		Assert.notNull(aclCache, "AclCache required");
 		Assert.notNull(aclAuthorizationStrategy, "AclAuthorizationStrategy required");
 		Assert.notNull(grantingStrategy, "grantingStrategy required");
-		jdbcTemplate = new JdbcTemplate(dataSource);
+		this.jdbcTemplate = new JdbcTemplate(dataSource);
 		this.aclCache = aclCache;
 		this.aclAuthorizationStrategy = aclAuthorizationStrategy;
 		this.grantingStrategy = grantingStrategy;
 		this.aclClassIdUtils = new AclClassIdUtils();
-		fieldAces.setAccessible(true);
-		fieldAcl.setAccessible(true);
+		this.fieldAces.setAccessible(true);
+		this.fieldAcl.setAccessible(true);
 	}
 
 	private String computeRepeatingSql(String repeatingSql, int requiredRepetitions) {
 		assert requiredRepetitions > 0 : "requiredRepetitions must be > 0";
 
-		final String startSql = selectClause;
+		final String startSql = this.selectClause;
 
-		final String endSql = orderByClause;
+		final String endSql = this.orderByClause;
 
 		StringBuilder sqlStringBldr = new StringBuilder(
 				startSql.length() + endSql.length() + requiredRepetitions * (repeatingSql.length() + 4));
@@ -192,7 +192,7 @@ public class BasicLookupStrategy implements LookupStrategy {
 	@SuppressWarnings("unchecked")
 	private List<AccessControlEntryImpl> readAces(AclImpl acl) {
 		try {
-			return (List<AccessControlEntryImpl>) fieldAces.get(acl);
+			return (List<AccessControlEntryImpl>) this.fieldAces.get(acl);
 		}
 		catch (IllegalAccessException e) {
 			throw new IllegalStateException("Could not obtain AclImpl.aces field", e);
@@ -201,7 +201,7 @@ public class BasicLookupStrategy implements LookupStrategy {
 
 	private void setAclOnAce(AccessControlEntryImpl ace, AclImpl acl) {
 		try {
-			fieldAcl.set(ace, acl);
+			this.fieldAcl.set(ace, acl);
 		}
 		catch (IllegalAccessException e) {
 			throw new IllegalStateException("Could not or set AclImpl on AccessControlEntryImpl fields", e);
@@ -210,7 +210,7 @@ public class BasicLookupStrategy implements LookupStrategy {
 
 	private void setAces(AclImpl acl, List<AccessControlEntryImpl> aces) {
 		try {
-			fieldAces.set(acl, aces);
+			this.fieldAces.set(acl, aces);
 		}
 		catch (IllegalAccessException e) {
 			throw new IllegalStateException("Could not set AclImpl entries", e);
@@ -228,9 +228,9 @@ public class BasicLookupStrategy implements LookupStrategy {
 		Assert.notNull(acls, "ACLs are required");
 		Assert.notEmpty(findNow, "Items to find now required");
 
-		String sql = computeRepeatingSql(lookupPrimaryKeysWhereClause, findNow.size());
+		String sql = computeRepeatingSql(this.lookupPrimaryKeysWhereClause, findNow.size());
 
-		Set<Long> parentsToLookup = jdbcTemplate.query(sql, ps -> {
+		Set<Long> parentsToLookup = this.jdbcTemplate.query(sql, ps -> {
 			int i = 0;
 
 			for (Long toFind : findNow) {
@@ -265,7 +265,7 @@ public class BasicLookupStrategy implements LookupStrategy {
 	 * automatically create entries if required)
 	 */
 	public final Map<ObjectIdentity, Acl> readAclsById(List<ObjectIdentity> objects, List<Sid> sids) {
-		Assert.isTrue(batchSize >= 1, "BatchSize must be >= 1");
+		Assert.isTrue(this.batchSize >= 1, "BatchSize must be >= 1");
 		Assert.notEmpty(objects, "Objects to lookup required");
 
 		// Map<ObjectIdentity,Acl>
@@ -288,7 +288,7 @@ public class BasicLookupStrategy implements LookupStrategy {
 
 			// Check cache for the present ACL entry
 			if (!aclFound) {
-				Acl acl = aclCache.getFromCache(oid);
+				Acl acl = this.aclCache.getFromCache(oid);
 
 				// Ensure any cached element supports all the requested SIDs
 				// (they should always, as our base impl doesn't filter on SID)
@@ -321,7 +321,7 @@ public class BasicLookupStrategy implements LookupStrategy {
 					// Add the loaded batch to the cache
 
 					for (Acl loadedAcl : loadedBatch.values()) {
-						aclCache.putInCache((AclImpl) loadedAcl);
+						this.aclCache.putInCache((AclImpl) loadedAcl);
 					}
 
 					currentBatchToLoad.clear();
@@ -354,9 +354,9 @@ public class BasicLookupStrategy implements LookupStrategy {
 
 		// Make the "acls" map contain all requested objectIdentities
 		// (including markers to each parent in the hierarchy)
-		String sql = computeRepeatingSql(lookupObjectIdentitiesWhereClause, objectIdentities.size());
+		String sql = computeRepeatingSql(this.lookupObjectIdentitiesWhereClause, objectIdentities.size());
 
-		Set<Long> parentsToLookup = jdbcTemplate.query(sql, ps -> {
+		Set<Long> parentsToLookup = this.jdbcTemplate.query(sql, ps -> {
 			int i = 0;
 			for (ObjectIdentity oid : objectIdentities) {
 				// Determine prepared statement values for this iteration
@@ -421,8 +421,8 @@ public class BasicLookupStrategy implements LookupStrategy {
 		}
 
 		// Now we have the parent (if there is one), create the true AclImpl
-		AclImpl result = new AclImpl(inputAcl.getObjectIdentity(), inputAcl.getId(), aclAuthorizationStrategy,
-				grantingStrategy, parent, null, inputAcl.isEntriesInheriting(), inputAcl.getOwner());
+		AclImpl result = new AclImpl(inputAcl.getObjectIdentity(), inputAcl.getId(), this.aclAuthorizationStrategy,
+				this.grantingStrategy, parent, null, inputAcl.isEntriesInheriting(), inputAcl.getOwner());
 
 		// Copy the "aces" from the input to the destination
 
@@ -548,27 +548,27 @@ public class BasicLookupStrategy implements LookupStrategy {
 
 			while (rs.next()) {
 				// Convert current row into an Acl (albeit with a StubAclParent)
-				convertCurrentResultIntoObject(acls, rs);
+				convertCurrentResultIntoObject(this.acls, rs);
 
 				// Figure out if this row means we need to lookup another parent
 				long parentId = rs.getLong("parent_object");
 
 				if (parentId != 0) {
 					// See if it's already in the "acls"
-					if (acls.containsKey(parentId)) {
+					if (this.acls.containsKey(parentId)) {
 						continue; // skip this while iteration
 					}
 
 					// Now try to find it in the cache
-					MutableAcl cached = aclCache.getFromCache(parentId);
+					MutableAcl cached = BasicLookupStrategy.this.aclCache.getFromCache(parentId);
 
-					if ((cached == null) || !cached.isSidLoaded(sids)) {
+					if ((cached == null) || !cached.isSidLoaded(this.sids)) {
 						parentIdsToLookup.add(parentId);
 					}
 					else {
 						// Pop into the acls map, so our convert method doesn't
 						// need to deal with an unsynchronized AclCache
-						acls.put(cached.getId(), cached);
+						this.acls.put(cached.getId(), cached);
 					}
 				}
 			}
@@ -597,7 +597,7 @@ public class BasicLookupStrategy implements LookupStrategy {
 				// If the Java type is a String, check to see if we can convert it to the
 				// target id type, e.g. UUID.
 				Serializable identifier = (Serializable) rs.getObject("object_id_identity");
-				identifier = aclClassIdUtils.identifierFrom(identifier, rs);
+				identifier = BasicLookupStrategy.this.aclClassIdUtils.identifierFrom(identifier, rs);
 				ObjectIdentity objectIdentity = new ObjectIdentityImpl(rs.getString("class"), identifier);
 
 				Acl parentAcl = null;
@@ -610,8 +610,8 @@ public class BasicLookupStrategy implements LookupStrategy {
 				boolean entriesInheriting = rs.getBoolean("entries_inheriting");
 				Sid owner = createSid(rs.getBoolean("acl_principal"), rs.getString("acl_sid"));
 
-				acl = new AclImpl(objectIdentity, id, aclAuthorizationStrategy, grantingStrategy, parentAcl, null,
-						entriesInheriting, owner);
+				acl = new AclImpl(objectIdentity, id, BasicLookupStrategy.this.aclAuthorizationStrategy,
+						BasicLookupStrategy.this.grantingStrategy, parentAcl, null, entriesInheriting, owner);
 
 				acls.put(id, acl);
 			}
@@ -624,7 +624,7 @@ public class BasicLookupStrategy implements LookupStrategy {
 				Sid recipient = createSid(rs.getBoolean("ace_principal"), rs.getString("ace_sid"));
 
 				int mask = rs.getInt("mask");
-				Permission permission = permissionFactory.buildFromMask(mask);
+				Permission permission = BasicLookupStrategy.this.permissionFactory.buildFromMask(mask);
 				boolean granting = rs.getBoolean("granting");
 				boolean auditSuccess = rs.getBoolean("audit_success");
 				boolean auditFailure = rs.getBoolean("audit_failure");
@@ -657,7 +657,7 @@ public class BasicLookupStrategy implements LookupStrategy {
 		}
 
 		public Long getId() {
-			return id;
+			return this.id;
 		}
 
 		public ObjectIdentity getObjectIdentity() {

acl/src/main/java/org/springframework/security/acls/jdbc/JdbcAclService.java

@@ -92,10 +92,10 @@ public class JdbcAclService implements AclService {
 
 	public List<ObjectIdentity> findChildren(ObjectIdentity parentIdentity) {
 		Object[] args = { parentIdentity.getIdentifier().toString(), parentIdentity.getType() };
-		List<ObjectIdentity> objects = jdbcOperations.query(findChildrenSql, args, (rs, rowNum) -> {
+		List<ObjectIdentity> objects = this.jdbcOperations.query(this.findChildrenSql, args, (rs, rowNum) -> {
 			String javaType = rs.getString("class");
 			Serializable identifier = (Serializable) rs.getObject("obj_id");
-			identifier = aclClassIdUtils.identifierFrom(identifier, rs);
+			identifier = this.aclClassIdUtils.identifierFrom(identifier, rs);
 			return new ObjectIdentityImpl(javaType, identifier);
 		});
 
@@ -124,7 +124,7 @@ public class JdbcAclService implements AclService {
 
 	public Map<ObjectIdentity, Acl> readAclsById(List<ObjectIdentity> objects, List<Sid> sids)
 			throws NotFoundException {
-		Map<ObjectIdentity, Acl> result = lookupStrategy.readAclsById(objects, sids);
+		Map<ObjectIdentity, Acl> result = this.lookupStrategy.readAclsById(objects, sids);
 
 		// Check every requested object identity was found (throw NotFoundException if
 		// needed)
@@ -163,7 +163,7 @@ public class JdbcAclService implements AclService {
 	}
 
 	protected boolean isAclClassIdSupported() {
-		return aclClassIdSupported;
+		return this.aclClassIdSupported;
 	}
 
 }

acl/src/main/java/org/springframework/security/acls/jdbc/JdbcMutableAclService.java

@@ -136,7 +136,7 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 		if (acl.getEntries().isEmpty()) {
 			return;
 		}
-		jdbcOperations.batchUpdate(insertEntry, new BatchPreparedStatementSetter() {
+		this.jdbcOperations.batchUpdate(this.insertEntry, new BatchPreparedStatementSetter() {
 			public int getBatchSize() {
 				return acl.getEntries().size();
 			}
@@ -168,7 +168,8 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 	protected void createObjectIdentity(ObjectIdentity object, Sid owner) {
 		Long sidId = createOrRetrieveSidPrimaryKey(owner, true);
 		Long classId = createOrRetrieveClassPrimaryKey(object.getType(), true, object.getIdentifier().getClass());
-		jdbcOperations.update(insertObjectIdentity, classId, object.getIdentifier().toString(), sidId, Boolean.TRUE);
+		this.jdbcOperations.update(this.insertObjectIdentity, classId, object.getIdentifier().toString(), sidId,
+				Boolean.TRUE);
 	}
 
 	/**
@@ -179,7 +180,8 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 	 * @return the primary key or null if not found
 	 */
 	protected Long createOrRetrieveClassPrimaryKey(String type, boolean allowCreate, Class idType) {
-		List<Long> classIds = jdbcOperations.queryForList(selectClassPrimaryKey, new Object[] { type }, Long.class);
+		List<Long> classIds = this.jdbcOperations.queryForList(this.selectClassPrimaryKey, new Object[] { type },
+				Long.class);
 
 		if (!classIds.isEmpty()) {
 			return classIds.get(0);
@@ -187,13 +189,13 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 
 		if (allowCreate) {
 			if (!isAclClassIdSupported()) {
-				jdbcOperations.update(insertClass, type);
+				this.jdbcOperations.update(this.insertClass, type);
 			}
 			else {
-				jdbcOperations.update(insertClass, type, idType.getCanonicalName());
+				this.jdbcOperations.update(this.insertClass, type, idType.getCanonicalName());
 			}
 			Assert.isTrue(TransactionSynchronizationManager.isSynchronizationActive(), "Transaction must be running");
-			return jdbcOperations.queryForObject(classIdentityQuery, Long.class);
+			return this.jdbcOperations.queryForObject(this.classIdentityQuery, Long.class);
 		}
 
 		return null;
@@ -238,17 +240,17 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 	 */
 	protected Long createOrRetrieveSidPrimaryKey(String sidName, boolean sidIsPrincipal, boolean allowCreate) {
 
-		List<Long> sidIds = jdbcOperations.queryForList(selectSidPrimaryKey, new Object[] { sidIsPrincipal, sidName },
-				Long.class);
+		List<Long> sidIds = this.jdbcOperations.queryForList(this.selectSidPrimaryKey,
+				new Object[] { sidIsPrincipal, sidName }, Long.class);
 
 		if (!sidIds.isEmpty()) {
 			return sidIds.get(0);
 		}
 
 		if (allowCreate) {
-			jdbcOperations.update(insertSid, sidIsPrincipal, sidName);
+			this.jdbcOperations.update(this.insertSid, sidIsPrincipal, sidName);
 			Assert.isTrue(TransactionSynchronizationManager.isSynchronizationActive(), "Transaction must be running");
-			return jdbcOperations.queryForObject(sidIdentityQuery, Long.class);
+			return this.jdbcOperations.queryForObject(this.sidIdentityQuery, Long.class);
 		}
 
 		return null;
@@ -267,7 +269,7 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 			}
 		}
 		else {
-			if (!foreignKeysInDatabase) {
+			if (!this.foreignKeysInDatabase) {
 				// We need to perform a manual verification for what a FK would normally
 				// do
 				// We generally don't do this, in the interests of deadlock management
@@ -288,7 +290,7 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 		deleteObjectIdentity(oidPrimaryKey);
 
 		// Clear the cache
-		aclCache.evictFromCache(objectIdentity);
+		this.aclCache.evictFromCache(objectIdentity);
 	}
 
 	/**
@@ -297,7 +299,7 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 	 * @param oidPrimaryKey the rows in acl_entry to delete
 	 */
 	protected void deleteEntries(Long oidPrimaryKey) {
-		jdbcOperations.update(deleteEntryByObjectIdentityForeignKey, oidPrimaryKey);
+		this.jdbcOperations.update(this.deleteEntryByObjectIdentityForeignKey, oidPrimaryKey);
 	}
 
 	/**
@@ -310,7 +312,7 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 	 */
 	protected void deleteObjectIdentity(Long oidPrimaryKey) {
 		// Delete the acl_object_identity row
-		jdbcOperations.update(deleteObjectIdentityByPrimaryKey, oidPrimaryKey);
+		this.jdbcOperations.update(this.deleteObjectIdentityByPrimaryKey, oidPrimaryKey);
 	}
 
 	/**
@@ -322,7 +324,7 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 	 */
 	protected Long retrieveObjectIdentityPrimaryKey(ObjectIdentity oid) {
 		try {
-			return jdbcOperations.queryForObject(selectObjectIdentityPrimaryKey, Long.class, oid.getType(),
+			return this.jdbcOperations.queryForObject(this.selectObjectIdentityPrimaryKey, Long.class, oid.getType(),
 					oid.getIdentifier().toString());
 		}
 		catch (DataAccessException notFound) {
@@ -364,7 +366,7 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 				clearCacheIncludingChildren(child);
 			}
 		}
-		aclCache.evictFromCache(objectIdentity);
+		this.aclCache.evictFromCache(objectIdentity);
 	}
 
 	/**
@@ -388,7 +390,7 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS
 		Assert.notNull(acl.getOwner(), "Owner is required in this implementation");
 
 		Long ownerSid = createOrRetrieveSidPrimaryKey(acl.getOwner(), true);
-		int count = jdbcOperations.update(updateObjectIdentity, parentId, ownerSid, acl.isEntriesInheriting(),
+		int count = this.jdbcOperations.update(this.updateObjectIdentity, parentId, ownerSid, acl.isEntriesInheriting(),
 				acl.getId());
 
 		if (count != 1) {