From 2306d987e9f00390cf0644ad6c54bc56a870144e Mon Sep 17 00:00:00 2001 From: Lars Grefer Date: Thu, 1 Aug 2019 23:27:18 +0200 Subject: [PATCH] Cleanup unnecessary boxing --- .../acls/domain/DefaultPermissionFactory.java | 9 +++-- .../acls/jdbc/BasicLookupStrategy.java | 12 +++---- .../acls/jdbc/JdbcMutableAclService.java | 6 ++-- .../domain/AccessControlImplEntryTests.java | 22 ++++++------ .../AclImplementationSecurityCheckTests.java | 14 ++++---- .../acls/domain/ObjectIdentityImplTests.java | 30 ++++++++-------- ...ectIdentityRetrievalStrategyImplTests.java | 2 +- .../AbstractBasicLookupStrategyTests.java | 36 +++++++++---------- ...icLookupStrategyWithAclClassTypeTests.java | 2 +- .../acls/jdbc/EhCacheBasedAclCacheTests.java | 8 ++--- .../acls/jdbc/JdbcMutableAclServiceTests.java | 26 +++++++------- .../jdbc/SpringCacheBasedAclCacheTests.java | 30 ++++++++-------- .../config/http/HttpConfigurationBuilder.java | 4 +-- .../LdapUserServiceBeanDefinitionParser.java | 4 +-- .../security/TargetObject.java | 2 +- .../security/access/SecurityConfigTests.java | 2 +- .../AfterInvocationProviderManagerTests.java | 2 +- .../AbstractAuthenticationTokenTests.java | 2 +- .../SimpleGrantedAuthorityTests.java | 2 +- .../KeyBasedPersistenceTokenServiceTests.java | 2 +- .../ldap/SpringSecurityLdapTemplate.java | 2 +- .../PasswordPolicyResponseControl.java | 2 +- ...cessTokenResponseHttpMessageConverter.java | 2 +- .../contact/AddDeleteContactController.java | 2 +- .../contact/AdminPermissionController.java | 8 ++--- .../sample/contact/ContactManagerBackend.java | 2 +- .../sample/contact/DataSourcePopulator.java | 6 ++-- .../java/sample/contact/IndexController.java | 8 ++--- .../sample/contact/ContactManagerTests.java | 6 ++-- .../main/java/sample/dms/AbstractElement.java | 2 +- .../main/java/sample/dms/DocumentDaoImpl.java | 22 ++++++------ .../taglibs/authz/AuthenticationTag.java | 2 +- .../security/web/PortMapperImpl.java | 4 +-- .../security/web/PortResolverImpl.java | 4 +-- .../channel/AbstractRetryEntryPoint.java | 2 +- .../LoginUrlAuthenticationEntryPoint.java | 4 +-- ...tSessionControlAuthenticationStrategy.java | 2 +- .../web/savedrequest/DefaultSavedRequest.java | 4 +-- .../web/savedrequest/FastHttpDateFormat.java | 4 +-- .../security/web/PortMapperImplTests.java | 12 +++---- 40 files changed, 158 insertions(+), 159 deletions(-) diff --git a/acl/src/main/java/org/springframework/security/acls/domain/DefaultPermissionFactory.java b/acl/src/main/java/org/springframework/security/acls/domain/DefaultPermissionFactory.java index 8e69029b2a..8061a916b5 100644 --- a/acl/src/main/java/org/springframework/security/acls/domain/DefaultPermissionFactory.java +++ b/acl/src/main/java/org/springframework/security/acls/domain/DefaultPermissionFactory.java @@ -100,7 +100,7 @@ public class DefaultPermissionFactory implements PermissionFactory { Assert.notNull(perm, "Permission required"); Assert.hasText(permissionName, "Permission name required"); - Integer mask = Integer.valueOf(perm.getMask()); + Integer mask = perm.getMask(); // Ensure no existing Permission uses this integer or code Assert.isTrue(!registeredPermissionsByInteger.containsKey(mask), @@ -114,10 +114,10 @@ public class DefaultPermissionFactory implements PermissionFactory { } public Permission buildFromMask(int mask) { - if (registeredPermissionsByInteger.containsKey(Integer.valueOf(mask))) { + if (registeredPermissionsByInteger.containsKey(mask)) { // The requested mask has an exact match against a statically-defined // Permission, so return it - return registeredPermissionsByInteger.get(Integer.valueOf(mask)); + return registeredPermissionsByInteger.get(mask); } // To get this far, we have to use a CumulativePermission @@ -127,8 +127,7 @@ public class DefaultPermissionFactory implements PermissionFactory { int permissionToCheck = 1 << i; if ((mask & permissionToCheck) == permissionToCheck) { - Permission p = registeredPermissionsByInteger.get(Integer - .valueOf(permissionToCheck)); + Permission p = registeredPermissionsByInteger.get(permissionToCheck); if (p == null) { throw new IllegalStateException("Mask '" + permissionToCheck diff --git a/acl/src/main/java/org/springframework/security/acls/jdbc/BasicLookupStrategy.java b/acl/src/main/java/org/springframework/security/acls/jdbc/BasicLookupStrategy.java index 270c13cd78..faee44d5f0 100644 --- a/acl/src/main/java/org/springframework/security/acls/jdbc/BasicLookupStrategy.java +++ b/acl/src/main/java/org/springframework/security/acls/jdbc/BasicLookupStrategy.java @@ -593,15 +593,15 @@ public class BasicLookupStrategy implements LookupStrategy { if (parentId != 0) { // See if it's already in the "acls" - if (acls.containsKey(new Long(parentId))) { + if (acls.containsKey(parentId)) { continue; // skip this while iteration } // Now try to find it in the cache - MutableAcl cached = aclCache.getFromCache(new Long(parentId)); + MutableAcl cached = aclCache.getFromCache(parentId); if ((cached == null) || !cached.isSidLoaded(sids)) { - parentIdsToLookup.add(new Long(parentId)); + parentIdsToLookup.add(parentId); } else { // Pop into the acls map, so our convert method doesn't @@ -627,7 +627,7 @@ public class BasicLookupStrategy implements LookupStrategy { */ private void convertCurrentResultIntoObject(Map acls, ResultSet rs) throws SQLException { - Long id = new Long(rs.getLong("acl_id")); + Long id = rs.getLong("acl_id"); // If we already have an ACL for this ID, just create the ACE Acl acl = acls.get(id); @@ -645,7 +645,7 @@ public class BasicLookupStrategy implements LookupStrategy { long parentAclId = rs.getLong("parent_object"); if (parentAclId != 0) { - parentAcl = new StubAclParent(Long.valueOf(parentAclId)); + parentAcl = new StubAclParent(parentAclId); } boolean entriesInheriting = rs.getBoolean("entries_inheriting"); @@ -662,7 +662,7 @@ public class BasicLookupStrategy implements LookupStrategy { // It is permissible to have no ACEs in an ACL (which is detected by a null // ACE_SID) if (rs.getString("ace_sid") != null) { - Long aceId = new Long(rs.getLong("ace_id")); + Long aceId = rs.getLong("ace_id"); Sid recipient = createSid(rs.getBoolean("ace_principal"), rs.getString("ace_sid")); diff --git a/acl/src/main/java/org/springframework/security/acls/jdbc/JdbcMutableAclService.java b/acl/src/main/java/org/springframework/security/acls/jdbc/JdbcMutableAclService.java index 4d2ff838ed..cf43adf1a2 100644 --- a/acl/src/main/java/org/springframework/security/acls/jdbc/JdbcMutableAclService.java +++ b/acl/src/main/java/org/springframework/security/acls/jdbc/JdbcMutableAclService.java @@ -249,14 +249,14 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS boolean allowCreate) { List sidIds = jdbcOperations.queryForList(selectSidPrimaryKey, new Object[] { - Boolean.valueOf(sidIsPrincipal), sidName }, Long.class); + sidIsPrincipal, sidName }, Long.class); if (!sidIds.isEmpty()) { return sidIds.get(0); } if (allowCreate) { - jdbcOperations.update(insertSid, Boolean.valueOf(sidIsPrincipal), sidName); + jdbcOperations.update(insertSid, sidIsPrincipal, sidName); Assert.isTrue(TransactionSynchronizationManager.isSynchronizationActive(), "Transaction must be running"); return jdbcOperations.queryForObject(sidIdentityQuery, Long.class); @@ -410,7 +410,7 @@ public class JdbcMutableAclService extends JdbcAclService implements MutableAclS Long ownerSid = createOrRetrieveSidPrimaryKey(acl.getOwner(), true); int count = jdbcOperations.update(updateObjectIdentity, parentId, ownerSid, - Boolean.valueOf(acl.isEntriesInheriting()), acl.getId()); + acl.isEntriesInheriting(), acl.getId()); if (count != 1) { throw new NotFoundException("Unable to locate ACL to update"); diff --git a/acl/src/test/java/org/springframework/security/acls/domain/AccessControlImplEntryTests.java b/acl/src/test/java/org/springframework/security/acls/domain/AccessControlImplEntryTests.java index f1f67b83a7..bbf33dfef4 100644 --- a/acl/src/test/java/org/springframework/security/acls/domain/AccessControlImplEntryTests.java +++ b/acl/src/test/java/org/springframework/security/acls/domain/AccessControlImplEntryTests.java @@ -71,11 +71,11 @@ public class AccessControlImplEntryTests { Sid sid = new PrincipalSid("johndoe"); // Create a sample entry - AccessControlEntry ace = new AccessControlEntryImpl(Long.valueOf(1), mockAcl, + AccessControlEntry ace = new AccessControlEntryImpl(1L, mockAcl, sid, BasePermission.ADMINISTRATION, true, true, true); // and check every get() method - assertThat(ace.getId()).isEqualTo(new Long(1)); + assertThat(ace.getId()).isEqualTo(1L); assertThat(ace.getAcl()).isEqualTo(mockAcl); assertThat(ace.getSid()).isEqualTo(sid); assertThat(ace.isGranting()).isTrue(); @@ -92,26 +92,26 @@ public class AccessControlImplEntryTests { when(mockAcl.getObjectIdentity()).thenReturn(oid); Sid sid = new PrincipalSid("johndoe"); - AccessControlEntry ace = new AccessControlEntryImpl(Long.valueOf(1), mockAcl, + AccessControlEntry ace = new AccessControlEntryImpl(1L, mockAcl, sid, BasePermission.ADMINISTRATION, true, true, true); assertThat(ace).isNotNull(); - assertThat(ace).isNotEqualTo(Long.valueOf(100)); + assertThat(ace).isNotEqualTo(100L); assertThat(ace).isEqualTo(ace); - assertThat(ace).isEqualTo(new AccessControlEntryImpl(Long.valueOf(1), mockAcl, sid, + assertThat(ace).isEqualTo(new AccessControlEntryImpl(1L, mockAcl, sid, BasePermission.ADMINISTRATION, true, true, true)); - assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(Long.valueOf(2), mockAcl, sid, + assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(2L, mockAcl, sid, BasePermission.ADMINISTRATION, true, true, true)); - assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(Long.valueOf(1), mockAcl, + assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(1L, mockAcl, new PrincipalSid("scott"), BasePermission.ADMINISTRATION, true, true, true)); - assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(Long.valueOf(1), mockAcl, sid, + assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(1L, mockAcl, sid, BasePermission.WRITE, true, true, true)); - assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(Long.valueOf(1), mockAcl, sid, + assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(1L, mockAcl, sid, BasePermission.ADMINISTRATION, false, true, true)); - assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(Long.valueOf(1), mockAcl, sid, + assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(1L, mockAcl, sid, BasePermission.ADMINISTRATION, true, false, true)); - assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(Long.valueOf(1), mockAcl, sid, + assertThat(ace).isNotEqualTo(new AccessControlEntryImpl(1L, mockAcl, sid, BasePermission.ADMINISTRATION, true, true, false)); } } diff --git a/acl/src/test/java/org/springframework/security/acls/domain/AclImplementationSecurityCheckTests.java b/acl/src/test/java/org/springframework/security/acls/domain/AclImplementationSecurityCheckTests.java index f169499550..b482de6abc 100644 --- a/acl/src/test/java/org/springframework/security/acls/domain/AclImplementationSecurityCheckTests.java +++ b/acl/src/test/java/org/springframework/security/acls/domain/AclImplementationSecurityCheckTests.java @@ -57,12 +57,12 @@ public class AclImplementationSecurityCheckTests { auth.setAuthenticated(true); SecurityContextHolder.getContext().setAuthentication(auth); - ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, new Long(100)); + ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, 100L); AclAuthorizationStrategy aclAuthorizationStrategy = new AclAuthorizationStrategyImpl( new SimpleGrantedAuthority("ROLE_OWNERSHIP"), new SimpleGrantedAuthority( "ROLE_AUDITING"), new SimpleGrantedAuthority("ROLE_GENERAL")); - Acl acl = new AclImpl(identity, new Long(1), aclAuthorizationStrategy, + Acl acl = new AclImpl(identity, 1L, aclAuthorizationStrategy, new ConsoleAuditLogger()); aclAuthorizationStrategy.securityCheck(acl, @@ -76,7 +76,7 @@ public class AclImplementationSecurityCheckTests { AclAuthorizationStrategy aclAuthorizationStrategy2 = new AclAuthorizationStrategyImpl( new SimpleGrantedAuthority("ROLE_ONE"), new SimpleGrantedAuthority( "ROLE_TWO"), new SimpleGrantedAuthority("ROLE_THREE")); - Acl acl2 = new AclImpl(identity, new Long(1), aclAuthorizationStrategy2, + Acl acl2 = new AclImpl(identity, 1L, aclAuthorizationStrategy2, new ConsoleAuditLogger()); // Check access in case the principal has no authorization rights try { @@ -110,7 +110,7 @@ public class AclImplementationSecurityCheckTests { auth.setAuthenticated(true); SecurityContextHolder.getContext().setAuthentication(auth); - ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, new Long(100)); + ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, 100L); // Authorization strategy will require a different role for each access AclAuthorizationStrategy aclAuthorizationStrategy = new AclAuthorizationStrategyImpl( new SimpleGrantedAuthority("ROLE_OWNERSHIP"), new SimpleGrantedAuthority( @@ -118,7 +118,7 @@ public class AclImplementationSecurityCheckTests { // Let's give the principal the ADMINISTRATION permission, without // granting access - MutableAcl aclFirstDeny = new AclImpl(identity, new Long(1), + MutableAcl aclFirstDeny = new AclImpl(identity, 1L, aclAuthorizationStrategy, new ConsoleAuditLogger()); aclFirstDeny.insertAce(0, BasePermission.ADMINISTRATION, new PrincipalSid(auth), false); @@ -160,7 +160,7 @@ public class AclImplementationSecurityCheckTests { // Create another ACL and give the principal the ADMINISTRATION // permission, with granting access - MutableAcl aclFirstAllow = new AclImpl(identity, new Long(1), + MutableAcl aclFirstAllow = new AclImpl(identity, 1L, aclAuthorizationStrategy, new ConsoleAuditLogger()); aclFirstAllow.insertAce(0, BasePermission.ADMINISTRATION, new PrincipalSid(auth), true); @@ -184,7 +184,7 @@ public class AclImplementationSecurityCheckTests { } // Create an ACL with no ACE - MutableAcl aclNoACE = new AclImpl(identity, new Long(1), + MutableAcl aclNoACE = new AclImpl(identity, 1L, aclAuthorizationStrategy, new ConsoleAuditLogger()); try { aclAuthorizationStrategy.securityCheck(aclNoACE, diff --git a/acl/src/test/java/org/springframework/security/acls/domain/ObjectIdentityImplTests.java b/acl/src/test/java/org/springframework/security/acls/domain/ObjectIdentityImplTests.java index 1a18c02ed6..f87207963f 100644 --- a/acl/src/test/java/org/springframework/security/acls/domain/ObjectIdentityImplTests.java +++ b/acl/src/test/java/org/springframework/security/acls/domain/ObjectIdentityImplTests.java @@ -47,7 +47,7 @@ public class ObjectIdentityImplTests { // Check String-Serializable constructor required field try { - new ObjectIdentityImpl("", Long.valueOf(1)); + new ObjectIdentityImpl("", 1L); fail("It should have thrown IllegalArgumentException"); } catch (IllegalArgumentException expected) { @@ -63,7 +63,7 @@ public class ObjectIdentityImplTests { // The correct way of using String-Serializable constructor try { - new ObjectIdentityImpl(DOMAIN_CLASS, Long.valueOf(1)); + new ObjectIdentityImpl(DOMAIN_CLASS, 1L); } catch (IllegalArgumentException notExpected) { fail("It shouldn't have thrown IllegalArgumentException"); @@ -80,8 +80,8 @@ public class ObjectIdentityImplTests { @Test public void gettersReturnExpectedValues() throws Exception { - ObjectIdentity obj = new ObjectIdentityImpl(DOMAIN_CLASS, Long.valueOf(1)); - assertThat(obj.getIdentifier()).isEqualTo(Long.valueOf(1)); + ObjectIdentity obj = new ObjectIdentityImpl(DOMAIN_CLASS, 1L); + assertThat(obj.getIdentifier()).isEqualTo(1L); assertThat(obj.getType()).isEqualTo(MockIdDomainObject.class.getName()); } @@ -116,7 +116,7 @@ public class ObjectIdentityImplTests { } // getId() should return a Serializable object - mockId.setId(new Long(100)); + mockId.setId(100L); try { new ObjectIdentityImpl(mockId); } @@ -126,38 +126,38 @@ public class ObjectIdentityImplTests { @Test(expected = IllegalArgumentException.class) public void constructorRejectsInvalidTypeParameter() throws Exception { - new ObjectIdentityImpl("", Long.valueOf(1)); + new ObjectIdentityImpl("", 1L); } @Test public void testEquals() throws Exception { - ObjectIdentity obj = new ObjectIdentityImpl(DOMAIN_CLASS, Long.valueOf(1)); + ObjectIdentity obj = new ObjectIdentityImpl(DOMAIN_CLASS, 1L); MockIdDomainObject mockObj = new MockIdDomainObject(); - mockObj.setId(Long.valueOf(1)); + mockObj.setId(1L); String string = "SOME_STRING"; assertThat(string).isNotSameAs(obj); assertThat(obj).isNotNull(); assertThat(obj).isNotEqualTo("DIFFERENT_OBJECT_TYPE"); - assertThat(obj).isNotEqualTo(new ObjectIdentityImpl(DOMAIN_CLASS, Long.valueOf(2))); + assertThat(obj).isNotEqualTo(new ObjectIdentityImpl(DOMAIN_CLASS, 2L)); assertThat(obj).isNotEqualTo(new ObjectIdentityImpl( "org.springframework.security.acls.domain.ObjectIdentityImplTests$MockOtherIdDomainObject", - Long.valueOf(1))); + 1L)); assertThat(new ObjectIdentityImpl(DOMAIN_CLASS, 1L)).isEqualTo(obj); assertThat(new ObjectIdentityImpl(mockObj)).isEqualTo(obj); } @Test public void hashcodeIsDifferentForDifferentJavaTypes() throws Exception { - ObjectIdentity obj = new ObjectIdentityImpl(Object.class, Long.valueOf(1)); - ObjectIdentity obj2 = new ObjectIdentityImpl(String.class, Long.valueOf(1)); + ObjectIdentity obj = new ObjectIdentityImpl(Object.class, 1L); + ObjectIdentity obj2 = new ObjectIdentityImpl(String.class, 1L); assertThat(obj.hashCode()).isNotEqualTo(obj2.hashCode()); } @Test public void longAndIntegerIdsWithSameValueAreEqualAndHaveSameHashcode() { - ObjectIdentity obj = new ObjectIdentityImpl(Object.class, new Long(5)); - ObjectIdentity obj2 = new ObjectIdentityImpl(Object.class, Integer.valueOf(5)); + ObjectIdentity obj = new ObjectIdentityImpl(Object.class, 5L); + ObjectIdentity obj2 = new ObjectIdentityImpl(Object.class, 5); assertThat(obj2).isEqualTo(obj); assertThat(obj2.hashCode()).isEqualTo(obj.hashCode()); @@ -174,7 +174,7 @@ public class ObjectIdentityImplTests { @Test public void stringAndNumericIdsAreNotEqual() throws Exception { ObjectIdentity obj = new ObjectIdentityImpl(Object.class, "1000"); - ObjectIdentity obj2 = new ObjectIdentityImpl(Object.class, Long.valueOf(1000)); + ObjectIdentity obj2 = new ObjectIdentityImpl(Object.class, 1000L); assertThat(obj).isNotEqualTo(obj2); } diff --git a/acl/src/test/java/org/springframework/security/acls/domain/ObjectIdentityRetrievalStrategyImplTests.java b/acl/src/test/java/org/springframework/security/acls/domain/ObjectIdentityRetrievalStrategyImplTests.java index 71bcbdc7ac..16e6bb3238 100644 --- a/acl/src/test/java/org/springframework/security/acls/domain/ObjectIdentityRetrievalStrategyImplTests.java +++ b/acl/src/test/java/org/springframework/security/acls/domain/ObjectIdentityRetrievalStrategyImplTests.java @@ -33,7 +33,7 @@ public class ObjectIdentityRetrievalStrategyImplTests { @Test public void testObjectIdentityCreation() throws Exception { MockIdDomainObject domain = new MockIdDomainObject(); - domain.setId(Integer.valueOf(1)); + domain.setId(1); ObjectIdentityRetrievalStrategy retStrategy = new ObjectIdentityRetrievalStrategyImpl(); ObjectIdentity identity = retStrategy.getObjectIdentity(domain); diff --git a/acl/src/test/java/org/springframework/security/acls/jdbc/AbstractBasicLookupStrategyTests.java b/acl/src/test/java/org/springframework/security/acls/jdbc/AbstractBasicLookupStrategyTests.java index 81b7227694..62f92428ae 100644 --- a/acl/src/test/java/org/springframework/security/acls/jdbc/AbstractBasicLookupStrategyTests.java +++ b/acl/src/test/java/org/springframework/security/acls/jdbc/AbstractBasicLookupStrategyTests.java @@ -129,10 +129,10 @@ public abstract class AbstractBasicLookupStrategyTests { @Test public void testAclsRetrievalWithDefaultBatchSize() throws Exception { - ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, new Long(100)); - ObjectIdentity middleParentOid = new ObjectIdentityImpl(TARGET_CLASS, new Long(101)); + ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, 100L); + ObjectIdentity middleParentOid = new ObjectIdentityImpl(TARGET_CLASS, 101L); // Deliberately use an integer for the child, to reproduce bug report in SEC-819 - ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, Integer.valueOf(102)); + ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, 102); Map map = this.strategy .readAclsById(Arrays.asList(topParentOid, middleParentOid, childOid), null); @@ -141,9 +141,9 @@ public abstract class AbstractBasicLookupStrategyTests { @Test public void testAclsRetrievalFromCacheOnly() throws Exception { - ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, Integer.valueOf(100)); - ObjectIdentity middleParentOid = new ObjectIdentityImpl(TARGET_CLASS, new Long(101)); - ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, new Long(102)); + ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, 100); + ObjectIdentity middleParentOid = new ObjectIdentityImpl(TARGET_CLASS, 101L); + ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, 102L); // Objects were put in cache strategy.readAclsById(Arrays.asList(topParentOid, middleParentOid, childOid), null); @@ -158,9 +158,9 @@ public abstract class AbstractBasicLookupStrategyTests { @Test public void testAclsRetrievalWithCustomBatchSize() throws Exception { - ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, new Long(100)); - ObjectIdentity middleParentOid = new ObjectIdentityImpl(TARGET_CLASS, Integer.valueOf(101)); - ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, new Long(102)); + ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, 100L); + ObjectIdentity middleParentOid = new ObjectIdentityImpl(TARGET_CLASS, 101); + ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, 102L); // Set a batch size to allow multiple database queries in order to retrieve all // acls @@ -242,10 +242,10 @@ public abstract class AbstractBasicLookupStrategyTests { String query = "INSERT INTO acl_object_identity(ID,OBJECT_ID_CLASS,OBJECT_ID_IDENTITY,PARENT_OBJECT,OWNER_SID,ENTRIES_INHERITING) VALUES (6,2,103,1,1,1);"; getJdbcTemplate().execute(query); - ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(100)); - ObjectIdentity middleParentOid = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(101)); - ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(102)); - ObjectIdentity middleParent2Oid = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(103)); + ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, 100L); + ObjectIdentity middleParentOid = new ObjectIdentityImpl(TARGET_CLASS, 101L); + ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, 102L); + ObjectIdentity middleParent2Oid = new ObjectIdentityImpl(TARGET_CLASS, 103L); // Retrieve the child Map map = this.strategy.readAclsById(Arrays.asList(childOid), null); @@ -274,10 +274,10 @@ public abstract class AbstractBasicLookupStrategyTests { + "INSERT INTO acl_entry(ID,ACL_OBJECT_IDENTITY,ACE_ORDER,SID,MASK,GRANTING,AUDIT_SUCCESS,AUDIT_FAILURE) VALUES (7,6,0,1,1,1,0,0)"; getJdbcTemplate().execute(query); - ObjectIdentity grandParentOid = new ObjectIdentityImpl(TARGET_CLASS, new Long(104)); - ObjectIdentity parent1Oid = new ObjectIdentityImpl(TARGET_CLASS, new Long(105)); - ObjectIdentity parent2Oid = new ObjectIdentityImpl(TARGET_CLASS, Integer.valueOf(106)); - ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, Integer.valueOf(107)); + ObjectIdentity grandParentOid = new ObjectIdentityImpl(TARGET_CLASS, 104L); + ObjectIdentity parent1Oid = new ObjectIdentityImpl(TARGET_CLASS, 105L); + ObjectIdentity parent2Oid = new ObjectIdentityImpl(TARGET_CLASS, 106); + ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, 107); // First lookup only child, thus populating the cache with grandParent, // parent1 @@ -317,7 +317,7 @@ public abstract class AbstractBasicLookupStrategyTests { getJdbcTemplate().execute(query); - ObjectIdentity oid = new ObjectIdentityImpl(TARGET_CLASS, new Long(104)); + ObjectIdentity oid = new ObjectIdentityImpl(TARGET_CLASS, 104L); strategy.readAclsById(Arrays.asList(oid), Arrays.asList(BEN_SID)); } diff --git a/acl/src/test/java/org/springframework/security/acls/jdbc/BasicLookupStrategyWithAclClassTypeTests.java b/acl/src/test/java/org/springframework/security/acls/jdbc/BasicLookupStrategyWithAclClassTypeTests.java index f059540437..85617968aa 100644 --- a/acl/src/test/java/org/springframework/security/acls/jdbc/BasicLookupStrategyWithAclClassTypeTests.java +++ b/acl/src/test/java/org/springframework/security/acls/jdbc/BasicLookupStrategyWithAclClassTypeTests.java @@ -101,7 +101,7 @@ public class BasicLookupStrategyWithAclClassTypeTests extends AbstractBasicLooku @Test public void testReadObjectIdentityUsingLongTypeWithConversionServiceEnabled() { - ObjectIdentity oid = new ObjectIdentityImpl(TARGET_CLASS, new Long(100)); + ObjectIdentity oid = new ObjectIdentityImpl(TARGET_CLASS, 100L); Map foundAcls = uuidEnabledStrategy.readAclsById(Arrays.asList(oid), Arrays.asList(BEN_SID)); Assert.assertEquals(1, foundAcls.size()); Assert.assertNotNull(foundAcls.get(oid)); diff --git a/acl/src/test/java/org/springframework/security/acls/jdbc/EhCacheBasedAclCacheTests.java b/acl/src/test/java/org/springframework/security/acls/jdbc/EhCacheBasedAclCacheTests.java index 5f6cfd54b0..b73944154f 100644 --- a/acl/src/test/java/org/springframework/security/acls/jdbc/EhCacheBasedAclCacheTests.java +++ b/acl/src/test/java/org/springframework/security/acls/jdbc/EhCacheBasedAclCacheTests.java @@ -71,12 +71,12 @@ public class EhCacheBasedAclCacheTests { new ConsoleAuditLogger()), new AclAuthorizationStrategyImpl( new SimpleGrantedAuthority("ROLE_USER"))); - ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(100)); + ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, 100L); AclAuthorizationStrategy aclAuthorizationStrategy = new AclAuthorizationStrategyImpl( new SimpleGrantedAuthority("ROLE_OWNERSHIP"), new SimpleGrantedAuthority( "ROLE_AUDITING"), new SimpleGrantedAuthority("ROLE_GENERAL")); - acl = new AclImpl(identity, Long.valueOf(1), aclAuthorizationStrategy, + acl = new AclImpl(identity, 1L, aclAuthorizationStrategy, new ConsoleAuditLogger()); } @@ -188,11 +188,11 @@ public class EhCacheBasedAclCacheTests { SecurityContextHolder.getContext().setAuthentication(auth); ObjectIdentity identityParent = new ObjectIdentityImpl(TARGET_CLASS, - Long.valueOf(2)); + 2L); AclAuthorizationStrategy aclAuthorizationStrategy = new AclAuthorizationStrategyImpl( new SimpleGrantedAuthority("ROLE_OWNERSHIP"), new SimpleGrantedAuthority( "ROLE_AUDITING"), new SimpleGrantedAuthority("ROLE_GENERAL")); - MutableAcl parentAcl = new AclImpl(identityParent, Long.valueOf(2), + MutableAcl parentAcl = new AclImpl(identityParent, 2L, aclAuthorizationStrategy, new ConsoleAuditLogger()); acl.setParent(parentAcl); diff --git a/acl/src/test/java/org/springframework/security/acls/jdbc/JdbcMutableAclServiceTests.java b/acl/src/test/java/org/springframework/security/acls/jdbc/JdbcMutableAclServiceTests.java index 95f3b386ff..8e6e21cb32 100644 --- a/acl/src/test/java/org/springframework/security/acls/jdbc/JdbcMutableAclServiceTests.java +++ b/acl/src/test/java/org/springframework/security/acls/jdbc/JdbcMutableAclServiceTests.java @@ -78,11 +78,11 @@ public class JdbcMutableAclServiceTests extends // ================================================================================================ private final ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, - Long.valueOf(100)); + 100L); private final ObjectIdentity middleParentOid = new ObjectIdentityImpl(TARGET_CLASS, - Long.valueOf(101)); + 101L); private final ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, - Long.valueOf(102)); + 102L); @Autowired private JdbcMutableAclService jdbcMutableAclService; @@ -361,7 +361,7 @@ public class JdbcMutableAclServiceTests extends public void createAclForADuplicateDomainObject() throws Exception { SecurityContextHolder.getContext().setAuthentication(auth); ObjectIdentity duplicateOid = new ObjectIdentityImpl(TARGET_CLASS, - Long.valueOf(100)); + 100L); jdbcMutableAclService.createAcl(duplicateOid); // Try to add the same object second time try { @@ -428,7 +428,7 @@ public class JdbcMutableAclServiceTests extends // Check the cache assertThat(aclCache.getFromCache(getChildOid())).isNull(); - assertThat(aclCache.getFromCache(Long.valueOf(102))).isNull(); + assertThat(aclCache.getFromCache(102L)).isNull(); } /** SEC-1107 */ @@ -436,11 +436,11 @@ public class JdbcMutableAclServiceTests extends @Transactional public void identityWithIntegerIdIsSupportedByCreateAcl() throws Exception { SecurityContextHolder.getContext().setAuthentication(auth); - ObjectIdentity oid = new ObjectIdentityImpl(TARGET_CLASS, Integer.valueOf(101)); + ObjectIdentity oid = new ObjectIdentityImpl(TARGET_CLASS, 101); jdbcMutableAclService.createAcl(oid); assertThat(jdbcMutableAclService.readAclById(new ObjectIdentityImpl( - TARGET_CLASS, Long.valueOf(101)))).isNotNull(); + TARGET_CLASS, 101L))).isNotNull(); } /** @@ -454,8 +454,8 @@ public class JdbcMutableAclServiceTests extends auth.setAuthenticated(true); SecurityContextHolder.getContext().setAuthentication(auth); - ObjectIdentity parentOid = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(104)); - ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(105)); + ObjectIdentity parentOid = new ObjectIdentityImpl(TARGET_CLASS, 104L); + ObjectIdentity childOid = new ObjectIdentityImpl(TARGET_CLASS, 105L); MutableAcl parent = jdbcMutableAclService.createAcl(parentOid); MutableAcl child = jdbcMutableAclService.createAcl(childOid); @@ -491,11 +491,11 @@ public class JdbcMutableAclServiceTests extends "ROLE_IGNORED"); SecurityContextHolder.getContext().setAuthentication(auth); ObjectIdentityImpl rootObject = new ObjectIdentityImpl(TARGET_CLASS, - Long.valueOf(1)); + 1L); MutableAcl parent = jdbcMutableAclService.createAcl(rootObject); MutableAcl child = jdbcMutableAclService.createAcl(new ObjectIdentityImpl( - TARGET_CLASS, Long.valueOf(2))); + TARGET_CLASS, 2L)); child.setParent(parent); jdbcMutableAclService.updateAcl(child); @@ -507,7 +507,7 @@ public class JdbcMutableAclServiceTests extends jdbcMutableAclService.updateAcl(parent); child = (MutableAcl) jdbcMutableAclService.readAclById(new ObjectIdentityImpl( - TARGET_CLASS, Long.valueOf(2))); + TARGET_CLASS, 2L)); parent = (MutableAcl) child.getParentAcl(); @@ -528,7 +528,7 @@ public class JdbcMutableAclServiceTests extends SecurityContextHolder.getContext().setAuthentication(auth); ObjectIdentity topParentOid = new ObjectIdentityImpl(TARGET_CLASS, - Long.valueOf(110)); + 110L); MutableAcl topParent = jdbcMutableAclService.createAcl(topParentOid); // Add an ACE permission entry diff --git a/acl/src/test/java/org/springframework/security/acls/jdbc/SpringCacheBasedAclCacheTests.java b/acl/src/test/java/org/springframework/security/acls/jdbc/SpringCacheBasedAclCacheTests.java index 25182626bd..d1c070db78 100644 --- a/acl/src/test/java/org/springframework/security/acls/jdbc/SpringCacheBasedAclCacheTests.java +++ b/acl/src/test/java/org/springframework/security/acls/jdbc/SpringCacheBasedAclCacheTests.java @@ -74,7 +74,7 @@ public class SpringCacheBasedAclCacheTests { public void cacheOperationsAclWithoutParent() throws Exception { Cache cache = getCache(); Map realCache = (Map) cache.getNativeCache(); - ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(100)); + ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, 100L); AclAuthorizationStrategy aclAuthorizationStrategy = new AclAuthorizationStrategyImpl( new SimpleGrantedAuthority("ROLE_OWNERSHIP"), new SimpleGrantedAuthority( "ROLE_AUDITING"), new SimpleGrantedAuthority("ROLE_GENERAL")); @@ -84,33 +84,33 @@ public class SpringCacheBasedAclCacheTests { auditLogger); SpringCacheBasedAclCache myCache = new SpringCacheBasedAclCache(cache, permissionGrantingStrategy, aclAuthorizationStrategy); - MutableAcl acl = new AclImpl(identity, Long.valueOf(1), aclAuthorizationStrategy, + MutableAcl acl = new AclImpl(identity, 1L, aclAuthorizationStrategy, auditLogger); assertThat(realCache).isEmpty(); myCache.putInCache(acl); // Check we can get from cache the same objects we put in - assertThat(acl).isEqualTo(myCache.getFromCache(Long.valueOf(1))); + assertThat(acl).isEqualTo(myCache.getFromCache(1L)); assertThat(acl).isEqualTo(myCache.getFromCache(identity)); // Put another object in cache - ObjectIdentity identity2 = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(101)); - MutableAcl acl2 = new AclImpl(identity2, Long.valueOf(2), + ObjectIdentity identity2 = new ObjectIdentityImpl(TARGET_CLASS, 101L); + MutableAcl acl2 = new AclImpl(identity2, 2L, aclAuthorizationStrategy, new ConsoleAuditLogger()); myCache.putInCache(acl2); // Try to evict an entry that doesn't exist - myCache.evictFromCache(Long.valueOf(3)); - myCache.evictFromCache(new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(102))); + myCache.evictFromCache(3L); + myCache.evictFromCache(new ObjectIdentityImpl(TARGET_CLASS, 102L)); assertThat(realCache).hasSize(4); - myCache.evictFromCache(Long.valueOf(1)); + myCache.evictFromCache(1L); assertThat(realCache).hasSize(2); // Check the second object inserted - assertThat(acl2).isEqualTo(myCache.getFromCache(Long.valueOf(2))); + assertThat(acl2).isEqualTo(myCache.getFromCache(2L)); assertThat(acl2).isEqualTo(myCache.getFromCache(identity2)); myCache.evictFromCache(identity2); @@ -128,9 +128,9 @@ public class SpringCacheBasedAclCacheTests { auth.setAuthenticated(true); SecurityContextHolder.getContext().setAuthentication(auth); - ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, Long.valueOf(1)); + ObjectIdentity identity = new ObjectIdentityImpl(TARGET_CLASS, 1L); ObjectIdentity identityParent = new ObjectIdentityImpl(TARGET_CLASS, - Long.valueOf(2)); + 2L); AclAuthorizationStrategy aclAuthorizationStrategy = new AclAuthorizationStrategyImpl( new SimpleGrantedAuthority("ROLE_OWNERSHIP"), new SimpleGrantedAuthority( "ROLE_AUDITING"), new SimpleGrantedAuthority("ROLE_GENERAL")); @@ -141,9 +141,9 @@ public class SpringCacheBasedAclCacheTests { SpringCacheBasedAclCache myCache = new SpringCacheBasedAclCache(cache, permissionGrantingStrategy, aclAuthorizationStrategy); - MutableAcl acl = new AclImpl(identity, Long.valueOf(1), aclAuthorizationStrategy, + MutableAcl acl = new AclImpl(identity, 1L, aclAuthorizationStrategy, auditLogger); - MutableAcl parentAcl = new AclImpl(identityParent, Long.valueOf(2), + MutableAcl parentAcl = new AclImpl(identityParent, 2L, aclAuthorizationStrategy, auditLogger); acl.setParent(parentAcl); @@ -153,7 +153,7 @@ public class SpringCacheBasedAclCacheTests { assertThat(4).isEqualTo(realCache.size()); // Check we can get from cache the same objects we put in - AclImpl aclFromCache = (AclImpl) myCache.getFromCache(Long.valueOf(1)); + AclImpl aclFromCache = (AclImpl) myCache.getFromCache(1L); assertThat(aclFromCache).isEqualTo(acl); // SEC-951 check transient fields are set on parent assertThat(FieldUtils.getFieldValue(aclFromCache.getParentAcl(), @@ -162,7 +162,7 @@ public class SpringCacheBasedAclCacheTests { "permissionGrantingStrategy")).isNotNull(); assertThat(myCache.getFromCache(identity)).isEqualTo(acl); assertThat(FieldUtils.getFieldValue(aclFromCache, "aclAuthorizationStrategy")).isNotNull(); - AclImpl parentAclFromCache = (AclImpl) myCache.getFromCache(Long.valueOf(2)); + AclImpl parentAclFromCache = (AclImpl) myCache.getFromCache(2L); assertThat(parentAclFromCache).isEqualTo(parentAcl); assertThat(FieldUtils.getFieldValue(parentAclFromCache, "aclAuthorizationStrategy")).isNotNull(); diff --git a/config/src/main/java/org/springframework/security/config/http/HttpConfigurationBuilder.java b/config/src/main/java/org/springframework/security/config/http/HttpConfigurationBuilder.java index 30c04b72d1..cdaf09b7bd 100644 --- a/config/src/main/java/org/springframework/security/config/http/HttpConfigurationBuilder.java +++ b/config/src/main/java/org/springframework/security/config/http/HttpConfigurationBuilder.java @@ -442,8 +442,8 @@ class HttpConfigurationBuilder { if (sessionFixationProtectionRequired) { sessionFixationStrategy.addPropertyValue("migrateSessionAttributes", - Boolean.valueOf(sessionFixationAttribute - .equals(OPT_SESSION_FIXATION_MIGRATE_SESSION))); + sessionFixationAttribute + .equals(OPT_SESSION_FIXATION_MIGRATE_SESSION)); } } diff --git a/config/src/main/java/org/springframework/security/config/ldap/LdapUserServiceBeanDefinitionParser.java b/config/src/main/java/org/springframework/security/config/ldap/LdapUserServiceBeanDefinitionParser.java index 3857b0012d..219de13e33 100644 --- a/config/src/main/java/org/springframework/security/config/ldap/LdapUserServiceBeanDefinitionParser.java +++ b/config/src/main/java/org/springframework/security/config/ldap/LdapUserServiceBeanDefinitionParser.java @@ -131,14 +131,14 @@ public class LdapUserServiceBeanDefinitionParser extends BeanDefinition bd = registry .getBeanDefinition(BeanIds.CONTEXT_SOURCE_SETTING_POST_PROCESSOR); bd.getPropertyValues().addPropertyValue("defaultNameRequired", - Boolean.valueOf(defaultNameRequired)); + defaultNameRequired); } return; } BeanDefinitionBuilder bdb = BeanDefinitionBuilder .rootBeanDefinition(ContextSourceSettingPostProcessor.class); - bdb.addPropertyValue("defaultNameRequired", Boolean.valueOf(defaultNameRequired)); + bdb.addPropertyValue("defaultNameRequired", defaultNameRequired); registry.registerBeanDefinition(BeanIds.CONTEXT_SOURCE_SETTING_POST_PROCESSOR, bdb.getBeanDefinition()); } diff --git a/core/src/test/java/org/springframework/security/TargetObject.java b/core/src/test/java/org/springframework/security/TargetObject.java index 0f7fafa7b9..612d401b59 100644 --- a/core/src/test/java/org/springframework/security/TargetObject.java +++ b/core/src/test/java/org/springframework/security/TargetObject.java @@ -29,7 +29,7 @@ public class TargetObject implements ITargetObject { // ======================================================================================================== public Integer computeHashCode(String input) { - return Integer.valueOf(input.hashCode()); + return input.hashCode(); } public int countLength(String input) { diff --git a/core/src/test/java/org/springframework/security/access/SecurityConfigTests.java b/core/src/test/java/org/springframework/security/access/SecurityConfigTests.java index e65a44b302..736b3ffb24 100644 --- a/core/src/test/java/org/springframework/security/access/SecurityConfigTests.java +++ b/core/src/test/java/org/springframework/security/access/SecurityConfigTests.java @@ -76,7 +76,7 @@ public class SecurityConfigTests { MockConfigAttribute mock2 = new MockConfigAttribute("NOT_EQUAL"); assertThat(security1).isNotEqualTo(mock2); - Integer int1 = Integer.valueOf(987); + Integer int1 = 987; assertThat(security1).isNotEqualTo(int1); } diff --git a/core/src/test/java/org/springframework/security/access/intercept/AfterInvocationProviderManagerTests.java b/core/src/test/java/org/springframework/security/access/intercept/AfterInvocationProviderManagerTests.java index 61c08622f5..9e045b97ad 100644 --- a/core/src/test/java/org/springframework/security/access/intercept/AfterInvocationProviderManagerTests.java +++ b/core/src/test/java/org/springframework/security/access/intercept/AfterInvocationProviderManagerTests.java @@ -103,7 +103,7 @@ public class AfterInvocationProviderManagerTests { List list = new Vector(); list.add(new MockAfterInvocationProvider("swap1", MethodInvocation.class, new SecurityConfig("GIVE_ME_SWAP1"))); - list.add(Integer.valueOf(45)); + list.add(45); list.add(new MockAfterInvocationProvider("swap3", MethodInvocation.class, new SecurityConfig("GIVE_ME_SWAP3"))); diff --git a/core/src/test/java/org/springframework/security/authentication/AbstractAuthenticationTokenTests.java b/core/src/test/java/org/springframework/security/authentication/AbstractAuthenticationTokenTests.java index 7ac1fe5a24..dc84fcb3d2 100644 --- a/core/src/test/java/org/springframework/security/authentication/AbstractAuthenticationTokenTests.java +++ b/core/src/test/java/org/springframework/security/authentication/AbstractAuthenticationTokenTests.java @@ -111,7 +111,7 @@ public class AbstractAuthenticationTokenTests { assertThat(!token1.equals(token7)).isTrue(); assertThat(!token7.equals(token1)).isTrue(); - assertThat(!token1.equals(Integer.valueOf(100))).isTrue(); + assertThat(!token1.equals(100)).isTrue(); } @Test diff --git a/core/src/test/java/org/springframework/security/core/authority/SimpleGrantedAuthorityTests.java b/core/src/test/java/org/springframework/security/core/authority/SimpleGrantedAuthorityTests.java index 4554301dc6..75dd614a73 100644 --- a/core/src/test/java/org/springframework/security/core/authority/SimpleGrantedAuthorityTests.java +++ b/core/src/test/java/org/springframework/security/core/authority/SimpleGrantedAuthorityTests.java @@ -42,7 +42,7 @@ public class SimpleGrantedAuthorityTests { assertThat(auth1.equals(mock(GrantedAuthority.class))).isFalse(); - assertThat(auth1.equals(Integer.valueOf(222))).isFalse(); + assertThat(auth1.equals(222)).isFalse(); } @Test diff --git a/core/src/test/java/org/springframework/security/core/token/KeyBasedPersistenceTokenServiceTests.java b/core/src/test/java/org/springframework/security/core/token/KeyBasedPersistenceTokenServiceTests.java index bda84bd2c8..4b9cfc0fb0 100644 --- a/core/src/test/java/org/springframework/security/core/token/KeyBasedPersistenceTokenServiceTests.java +++ b/core/src/test/java/org/springframework/security/core/token/KeyBasedPersistenceTokenServiceTests.java @@ -38,7 +38,7 @@ public class KeyBasedPersistenceTokenServiceTests { SecureRandomFactoryBean fb = new SecureRandomFactoryBean(); KeyBasedPersistenceTokenService service = new KeyBasedPersistenceTokenService(); service.setServerSecret("MY:SECRET$$$#"); - service.setServerInteger(Integer.valueOf(454545)); + service.setServerInteger(454545); try { SecureRandom rnd = fb.getObject(); service.setSecureRandom(rnd); diff --git a/ldap/src/main/java/org/springframework/security/ldap/SpringSecurityLdapTemplate.java b/ldap/src/main/java/org/springframework/security/ldap/SpringSecurityLdapTemplate.java index ad1245bad0..58cba41d1d 100644 --- a/ldap/src/main/java/org/springframework/security/ldap/SpringSecurityLdapTemplate.java +++ b/ldap/src/main/java/org/springframework/security/ldap/SpringSecurityLdapTemplate.java @@ -110,7 +110,7 @@ public class SpringSecurityLdapTemplate extends LdapTemplate { NamingEnumeration results = ctx.search(dn, comparisonFilter, new Object[] { value }, ctls); - Boolean match = Boolean.valueOf(results.hasMore()); + Boolean match = results.hasMore(); LdapUtils.closeEnumeration(results); return match; diff --git a/ldap/src/main/java/org/springframework/security/ldap/ppolicy/PasswordPolicyResponseControl.java b/ldap/src/main/java/org/springframework/security/ldap/ppolicy/PasswordPolicyResponseControl.java index 86e3240a18..8185d6c3b6 100755 --- a/ldap/src/main/java/org/springframework/security/ldap/ppolicy/PasswordPolicyResponseControl.java +++ b/ldap/src/main/java/org/springframework/security/ldap/ppolicy/PasswordPolicyResponseControl.java @@ -310,7 +310,7 @@ public class PasswordPolicyResponseControl extends PasswordPolicyControl { } private void setInChoice(boolean inChoice) { - this.inChoice = Boolean.valueOf(inChoice); + this.inChoice = inChoice; } } } diff --git a/oauth2/oauth2-core/src/main/java/org/springframework/security/oauth2/core/http/converter/OAuth2AccessTokenResponseHttpMessageConverter.java b/oauth2/oauth2-core/src/main/java/org/springframework/security/oauth2/core/http/converter/OAuth2AccessTokenResponseHttpMessageConverter.java index 75a6718ba3..eb731d2ca0 100644 --- a/oauth2/oauth2-core/src/main/java/org/springframework/security/oauth2/core/http/converter/OAuth2AccessTokenResponseHttpMessageConverter.java +++ b/oauth2/oauth2-core/src/main/java/org/springframework/security/oauth2/core/http/converter/OAuth2AccessTokenResponseHttpMessageConverter.java @@ -152,7 +152,7 @@ public class OAuth2AccessTokenResponseHttpMessageConverter extends AbstractHttpM long expiresIn = 0; if (tokenResponseParameters.containsKey(OAuth2ParameterNames.EXPIRES_IN)) { try { - expiresIn = Long.valueOf(tokenResponseParameters.get(OAuth2ParameterNames.EXPIRES_IN)); + expiresIn = Long.parseLong(tokenResponseParameters.get(OAuth2ParameterNames.EXPIRES_IN)); } catch (NumberFormatException ex) { } } diff --git a/samples/xml/contacts/src/main/java/sample/contact/AddDeleteContactController.java b/samples/xml/contacts/src/main/java/sample/contact/AddDeleteContactController.java index 1f2c662f95..3f0ac3d9de 100644 --- a/samples/xml/contacts/src/main/java/sample/contact/AddDeleteContactController.java +++ b/samples/xml/contacts/src/main/java/sample/contact/AddDeleteContactController.java @@ -70,7 +70,7 @@ public class AddDeleteContactController { @RequestMapping(value = "/secure/del.htm", method = RequestMethod.GET) public ModelAndView delContact(@RequestParam("contactId") int contactId) { - Contact contact = contactManager.getById(Long.valueOf(contactId)); + Contact contact = contactManager.getById((long) contactId); contactManager.delete(contact); return new ModelAndView("deleted", "contact", contact); diff --git a/samples/xml/contacts/src/main/java/sample/contact/AdminPermissionController.java b/samples/xml/contacts/src/main/java/sample/contact/AdminPermissionController.java index 8265654827..c44bf22f78 100644 --- a/samples/xml/contacts/src/main/java/sample/contact/AdminPermissionController.java +++ b/samples/xml/contacts/src/main/java/sample/contact/AdminPermissionController.java @@ -68,7 +68,7 @@ public final class AdminPermissionController implements MessageSourceAware { */ @RequestMapping(value = "/secure/adminPermission.htm", method = RequestMethod.GET) public ModelAndView displayAdminPage(@RequestParam("contactId") int contactId) { - Contact contact = contactManager.getById(Long.valueOf(contactId)); + Contact contact = contactManager.getById((long) contactId); Acl acl = aclService.readAclById(new ObjectIdentityImpl(contact)); Map model = new HashMap<>(); @@ -161,11 +161,11 @@ public final class AdminPermissionController implements MessageSourceAware { private Map listPermissions() { Map map = new LinkedHashMap<>(); - map.put(Integer.valueOf(BasePermission.ADMINISTRATION.getMask()), + map.put(BasePermission.ADMINISTRATION.getMask(), messages.getMessage("select.administer", "Administer")); - map.put(Integer.valueOf(BasePermission.READ.getMask()), + map.put(BasePermission.READ.getMask(), messages.getMessage("select.read", "Read")); - map.put(Integer.valueOf(BasePermission.DELETE.getMask()), + map.put(BasePermission.DELETE.getMask(), messages.getMessage("select.delete", "Delete")); return map; diff --git a/samples/xml/contacts/src/main/java/sample/contact/ContactManagerBackend.java b/samples/xml/contacts/src/main/java/sample/contact/ContactManagerBackend.java index f19e54c36b..9c6c24a01f 100644 --- a/samples/xml/contacts/src/main/java/sample/contact/ContactManagerBackend.java +++ b/samples/xml/contacts/src/main/java/sample/contact/ContactManagerBackend.java @@ -84,7 +84,7 @@ public class ContactManagerBackend extends ApplicationObjectSupport implements public void create(Contact contact) { // Create the Contact itself - contact.setId(Long.valueOf(counter++)); + contact.setId((long) counter++); contactDao.create(contact); // Grant the current principal administrative permission to the contact diff --git a/samples/xml/contacts/src/main/java/sample/contact/DataSourcePopulator.java b/samples/xml/contacts/src/main/java/sample/contact/DataSourcePopulator.java index 126925a990..8d856133fe 100644 --- a/samples/xml/contacts/src/main/java/sample/contact/DataSourcePopulator.java +++ b/samples/xml/contacts/src/main/java/sample/contact/DataSourcePopulator.java @@ -165,7 +165,7 @@ public class DataSourcePopulator implements InitializingBean { // Create acl_object_identity rows (and also acl_class rows as needed for (int i = 1; i < createEntities; i++) { final ObjectIdentity objectIdentity = new ObjectIdentityImpl(Contact.class, - Long.valueOf(i)); + (long) i); tt.execute(new TransactionCallback() { public Object doInTransaction(TransactionStatus arg0) { mutableAclService.createAcl(objectIdentity); @@ -230,7 +230,7 @@ public class DataSourcePopulator implements InitializingBean { private void changeOwner(int contactNumber, String newOwnerUsername) { AclImpl acl = (AclImpl) mutableAclService.readAclById(new ObjectIdentityImpl( - Contact.class, new Long(contactNumber))); + Contact.class, (long) contactNumber)); acl.setOwner(new PrincipalSid(newOwnerUsername)); updateAclInTransaction(acl); } @@ -242,7 +242,7 @@ public class DataSourcePopulator implements InitializingBean { private void grantPermissions(int contactNumber, String recipientUsername, Permission permission) { AclImpl acl = (AclImpl) mutableAclService.readAclById(new ObjectIdentityImpl( - Contact.class, Long.valueOf(contactNumber))); + Contact.class, (long) contactNumber)); acl.insertAce(acl.getEntries().size(), permission, new PrincipalSid( recipientUsername), true); updateAclInTransaction(acl); diff --git a/samples/xml/contacts/src/main/java/sample/contact/IndexController.java b/samples/xml/contacts/src/main/java/sample/contact/IndexController.java index 79bee88834..09c576862f 100644 --- a/samples/xml/contacts/src/main/java/sample/contact/IndexController.java +++ b/samples/xml/contacts/src/main/java/sample/contact/IndexController.java @@ -92,10 +92,10 @@ public class IndexController { Authentication user = SecurityContextHolder.getContext().getAuthentication(); for (Contact contact : myContactsList) { - hasDelete.put(contact, Boolean.valueOf(permissionEvaluator.hasPermission( - user, contact, HAS_DELETE))); - hasAdmin.put(contact, Boolean.valueOf(permissionEvaluator.hasPermission(user, - contact, HAS_ADMIN))); + hasDelete.put(contact, permissionEvaluator.hasPermission( + user, contact, HAS_DELETE)); + hasAdmin.put(contact, permissionEvaluator.hasPermission(user, + contact, HAS_ADMIN)); } Map model = new HashMap<>(); diff --git a/samples/xml/contacts/src/test/java/sample/contact/ContactManagerTests.java b/samples/xml/contacts/src/test/java/sample/contact/ContactManagerTests.java index efe1159527..9a9b8ec023 100644 --- a/samples/xml/contacts/src/test/java/sample/contact/ContactManagerTests.java +++ b/samples/xml/contacts/src/test/java/sample/contact/ContactManagerTests.java @@ -55,7 +55,7 @@ public class ContactManagerTests { void assertContainsContact(long id, List contacts) { for (Contact contact : contacts) { - if (contact.getId().equals(Long.valueOf(id))) { + if (contact.getId().equals(id)) { return; } } @@ -65,7 +65,7 @@ public class ContactManagerTests { void assertDoestNotContainContact(long id, List contacts) { for (Contact contact : contacts) { - if (contact.getId().equals(Long.valueOf(id))) { + if (contact.getId().equals(id)) { fail("List of contact should NOT (but did) contain: " + id); } } @@ -148,7 +148,7 @@ public class ContactManagerTests { assertDoestNotContainContact(5, contacts); - Contact c1 = contactManager.getById(new Long(4)); + Contact c1 = contactManager.getById(4L); contactManager.deletePermission(c1, new PrincipalSid("bob"), BasePermission.ADMINISTRATION); diff --git a/samples/xml/dms/src/main/java/sample/dms/AbstractElement.java b/samples/xml/dms/src/main/java/sample/dms/AbstractElement.java index 0b8ae05a7c..046e500b91 100755 --- a/samples/xml/dms/src/main/java/sample/dms/AbstractElement.java +++ b/samples/xml/dms/src/main/java/sample/dms/AbstractElement.java @@ -40,7 +40,7 @@ public abstract class AbstractElement { protected AbstractElement() { this.name = "/"; this.parent = null; - this.id = Long.valueOf(-1); + this.id = -1L; } /** diff --git a/samples/xml/dms/src/main/java/sample/dms/DocumentDaoImpl.java b/samples/xml/dms/src/main/java/sample/dms/DocumentDaoImpl.java index b4c437ca54..c3f7dd4b86 100755 --- a/samples/xml/dms/src/main/java/sample/dms/DocumentDaoImpl.java +++ b/samples/xml/dms/src/main/java/sample/dms/DocumentDaoImpl.java @@ -83,18 +83,18 @@ public class DocumentDaoImpl extends JdbcDaoSupport implements DocumentDao { new Object[] { id }, new RowMapper() { public Directory mapRow(ResultSet rs, int rowNumber) throws SQLException { - Long parentDirectoryId = new Long(rs - .getLong("parent_directory_id")); + Long parentDirectoryId = rs + .getLong("parent_directory_id"); Directory parentDirectory = Directory.ROOT_DIRECTORY; if (parentDirectoryId != null - && !parentDirectoryId.equals(new Long(-1))) { + && !parentDirectoryId.equals(-1L)) { // Need to go and lookup the parent, so do that first parentDirectory = getDirectoryWithImmediateParentPopulated(parentDirectoryId); } Directory directory = new Directory(rs .getString("directory_name"), parentDirectory); FieldUtils.setProtectedFieldValue("id", directory, - new Long(rs.getLong("id"))); + rs.getLong("id")); return directory; } }); @@ -108,8 +108,8 @@ public class DocumentDaoImpl extends JdbcDaoSupport implements DocumentDao { SELECT_FROM_DIRECTORY_NULL, new RowMapper() { public Directory mapRow(ResultSet rs, int rowNumber) throws SQLException { - return getDirectoryWithImmediateParentPopulated(new Long(rs - .getLong("id"))); + return getDirectoryWithImmediateParentPopulated(rs + .getLong("id")); } }); return directories.toArray(new AbstractElement[] {}); @@ -119,22 +119,22 @@ public class DocumentDaoImpl extends JdbcDaoSupport implements DocumentDao { new RowMapper() { public Directory mapRow(ResultSet rs, int rowNumber) throws SQLException { - return getDirectoryWithImmediateParentPopulated(new Long(rs - .getLong("id"))); + return getDirectoryWithImmediateParentPopulated(rs + .getLong("id")); } }); List files = getJdbcTemplate().query(SELECT_FROM_FILE, new Object[] { directory.getId() }, new RowMapper() { public File mapRow(ResultSet rs, int rowNumber) throws SQLException { - Long parentDirectoryId = new Long(rs - .getLong("parent_directory_id")); + Long parentDirectoryId = rs + .getLong("parent_directory_id"); Directory parentDirectory = null; if (parentDirectoryId != null) { parentDirectory = getDirectoryWithImmediateParentPopulated(parentDirectoryId); } File file = new File(rs.getString("file_name"), parentDirectory); FieldUtils.setProtectedFieldValue("id", file, - new Long(rs.getLong("id"))); + rs.getLong("id")); return file; } }); diff --git a/taglibs/src/main/java/org/springframework/security/taglibs/authz/AuthenticationTag.java b/taglibs/src/main/java/org/springframework/security/taglibs/authz/AuthenticationTag.java index ab49ac19d8..dbca2ae1eb 100644 --- a/taglibs/src/main/java/org/springframework/security/taglibs/authz/AuthenticationTag.java +++ b/taglibs/src/main/java/org/springframework/security/taglibs/authz/AuthenticationTag.java @@ -150,7 +150,7 @@ public class AuthenticationTag extends TagSupport { * Set HTML escaping for this tag, as boolean value. */ public void setHtmlEscape(String htmlEscape) throws JspException { - this.htmlEscape = Boolean.valueOf(htmlEscape); + this.htmlEscape = Boolean.parseBoolean(htmlEscape); } /** diff --git a/web/src/main/java/org/springframework/security/web/PortMapperImpl.java b/web/src/main/java/org/springframework/security/web/PortMapperImpl.java index 9846c5e300..5094dc2b99 100644 --- a/web/src/main/java/org/springframework/security/web/PortMapperImpl.java +++ b/web/src/main/java/org/springframework/security/web/PortMapperImpl.java @@ -42,8 +42,8 @@ public class PortMapperImpl implements PortMapper { public PortMapperImpl() { this.httpsPortMappings = new HashMap<>(); - this.httpsPortMappings.put(Integer.valueOf(80), Integer.valueOf(443)); - this.httpsPortMappings.put(Integer.valueOf(8080), Integer.valueOf(8443)); + this.httpsPortMappings.put(80, 443); + this.httpsPortMappings.put(8080, 8443); } // ~ Methods diff --git a/web/src/main/java/org/springframework/security/web/PortResolverImpl.java b/web/src/main/java/org/springframework/security/web/PortResolverImpl.java index 45a5530f0b..9acfedfdcf 100644 --- a/web/src/main/java/org/springframework/security/web/PortResolverImpl.java +++ b/web/src/main/java/org/springframework/security/web/PortResolverImpl.java @@ -54,11 +54,11 @@ public class PortResolverImpl implements PortResolver { String scheme = request.getScheme().toLowerCase(); if ("http".equals(scheme)) { - portLookup = portMapper.lookupHttpPort(Integer.valueOf(serverPort)); + portLookup = portMapper.lookupHttpPort(serverPort); } else if ("https".equals(scheme)) { - portLookup = portMapper.lookupHttpsPort(Integer.valueOf(serverPort)); + portLookup = portMapper.lookupHttpsPort(serverPort); } if (portLookup != null) { diff --git a/web/src/main/java/org/springframework/security/web/access/channel/AbstractRetryEntryPoint.java b/web/src/main/java/org/springframework/security/web/access/channel/AbstractRetryEntryPoint.java index aeb292edd9..74e5e29afb 100644 --- a/web/src/main/java/org/springframework/security/web/access/channel/AbstractRetryEntryPoint.java +++ b/web/src/main/java/org/springframework/security/web/access/channel/AbstractRetryEntryPoint.java @@ -63,7 +63,7 @@ public abstract class AbstractRetryEntryPoint implements ChannelEntryPoint { String redirectUrl = request.getRequestURI() + ((queryString == null) ? "" : ("?" + queryString)); - Integer currentPort = Integer.valueOf(portResolver.getServerPort(request)); + Integer currentPort = portResolver.getServerPort(request); Integer redirectPort = getMappedPort(currentPort); if (redirectPort != null) { diff --git a/web/src/main/java/org/springframework/security/web/authentication/LoginUrlAuthenticationEntryPoint.java b/web/src/main/java/org/springframework/security/web/authentication/LoginUrlAuthenticationEntryPoint.java index 483d15849c..c1b1595799 100644 --- a/web/src/main/java/org/springframework/security/web/authentication/LoginUrlAuthenticationEntryPoint.java +++ b/web/src/main/java/org/springframework/security/web/authentication/LoginUrlAuthenticationEntryPoint.java @@ -191,7 +191,7 @@ public class LoginUrlAuthenticationEntryPoint implements AuthenticationEntryPoin urlBuilder.setPathInfo(loginForm); if (forceHttps && "http".equals(scheme)) { - Integer httpsPort = portMapper.lookupHttpsPort(Integer.valueOf(serverPort)); + Integer httpsPort = portMapper.lookupHttpsPort(serverPort); if (httpsPort != null) { // Overwrite scheme and port in the redirect URL @@ -215,7 +215,7 @@ public class LoginUrlAuthenticationEntryPoint implements AuthenticationEntryPoin throws IOException, ServletException { int serverPort = portResolver.getServerPort(request); - Integer httpsPort = portMapper.lookupHttpsPort(Integer.valueOf(serverPort)); + Integer httpsPort = portMapper.lookupHttpsPort(serverPort); if (httpsPort != null) { RedirectUrlBuilder urlBuilder = new RedirectUrlBuilder(); diff --git a/web/src/main/java/org/springframework/security/web/authentication/session/ConcurrentSessionControlAuthenticationStrategy.java b/web/src/main/java/org/springframework/security/web/authentication/session/ConcurrentSessionControlAuthenticationStrategy.java index 68df38f902..b67983cba7 100644 --- a/web/src/main/java/org/springframework/security/web/authentication/session/ConcurrentSessionControlAuthenticationStrategy.java +++ b/web/src/main/java/org/springframework/security/web/authentication/session/ConcurrentSessionControlAuthenticationStrategy.java @@ -152,7 +152,7 @@ public class ConcurrentSessionControlAuthenticationStrategy implements if (exceptionIfMaximumExceeded || (sessions == null)) { throw new SessionAuthenticationException(messages.getMessage( "ConcurrentSessionControlAuthenticationStrategy.exceededAllowed", - new Object[] { Integer.valueOf(allowableSessions) }, + new Object[] {allowableSessions}, "Maximum sessions of {0} for this principal exceeded")); } diff --git a/web/src/main/java/org/springframework/security/web/savedrequest/DefaultSavedRequest.java b/web/src/main/java/org/springframework/security/web/savedrequest/DefaultSavedRequest.java index 8f530d4ff6..c0dd156549 100644 --- a/web/src/main/java/org/springframework/security/web/savedrequest/DefaultSavedRequest.java +++ b/web/src/main/java/org/springframework/security/web/savedrequest/DefaultSavedRequest.java @@ -234,8 +234,8 @@ public class DefaultSavedRequest implements SavedRequest { return false; } - if (!propertyEquals("serverPort", Integer.valueOf(this.serverPort), - Integer.valueOf(portResolver.getServerPort(request)))) { + if (!propertyEquals("serverPort", this.serverPort, + portResolver.getServerPort(request))) { return false; } diff --git a/web/src/main/java/org/springframework/security/web/savedrequest/FastHttpDateFormat.java b/web/src/main/java/org/springframework/security/web/savedrequest/FastHttpDateFormat.java index 1543fdf065..3f6c08bd3e 100644 --- a/web/src/main/java/org/springframework/security/web/savedrequest/FastHttpDateFormat.java +++ b/web/src/main/java/org/springframework/security/web/savedrequest/FastHttpDateFormat.java @@ -85,7 +85,7 @@ public class FastHttpDateFormat { */ public static String formatDate(long value, DateFormat threadLocalformat) { String cachedDate = null; - Long longValue = Long.valueOf(value); + Long longValue = value; try { cachedDate = formatCache.get(longValue); @@ -160,7 +160,7 @@ public class FastHttpDateFormat { return null; } - return new Long(date.getTime()); + return date.getTime(); } /** diff --git a/web/src/test/java/org/springframework/security/web/PortMapperImplTests.java b/web/src/test/java/org/springframework/security/web/PortMapperImplTests.java index 66dec69845..e6709763a8 100644 --- a/web/src/test/java/org/springframework/security/web/PortMapperImplTests.java +++ b/web/src/test/java/org/springframework/security/web/PortMapperImplTests.java @@ -36,14 +36,14 @@ public class PortMapperImplTests { @Test public void testDefaultMappingsAreKnown() throws Exception { PortMapperImpl portMapper = new PortMapperImpl(); - assertThat(portMapper.lookupHttpPort(Integer.valueOf(443))).isEqualTo( + assertThat(portMapper.lookupHttpPort(443)).isEqualTo( Integer.valueOf(80)); assertThat(Integer.valueOf(8080)).isEqualTo( - portMapper.lookupHttpPort(Integer.valueOf(8443))); + portMapper.lookupHttpPort(8443)); assertThat(Integer.valueOf(443)).isEqualTo( - portMapper.lookupHttpsPort(Integer.valueOf(80))); + portMapper.lookupHttpsPort(80)); assertThat(Integer.valueOf(8443)).isEqualTo( - portMapper.lookupHttpsPort(Integer.valueOf(8080))); + portMapper.lookupHttpsPort(8080)); } @Test @@ -107,9 +107,9 @@ public class PortMapperImplTests { portMapper.setPortMappings(map); - assertThat(portMapper.lookupHttpPort(Integer.valueOf(442))).isEqualTo( + assertThat(portMapper.lookupHttpPort(442)).isEqualTo( Integer.valueOf(79)); assertThat(Integer.valueOf(442)).isEqualTo( - portMapper.lookupHttpsPort(Integer.valueOf(79))); + portMapper.lookupHttpsPort(79)); } }