import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
@Override
public Map<String, String> getObject() throws Exception {
    Connection connection = dataSource.getConnection();
    PreparedStatement ps = connection.prepareStatement(sql);
    ResultSet rs = null;
    Map<String, String> filters = new LinkedHashMap<>();

    try {
        rs = ps.executeQuery();

        while (rs.next()) {

            String url = rs.getString(1);
            String permission = rs.getString(2);

            filters.put(url, String.format(PERMISSION_STRING, permission));
            LOGGER.debug("Load filter chain via JDBC: {} -> {}", url, permission);
        }
    } finally {
        JdbcUtils.closeResultSet(rs);
    }
    return filters;
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
public Map<String, String> getObject() throws Exception {
    Connection connection = dataSource.getConnection();
    PreparedStatement ps = connection.prepareStatement(sql);
    ResultSet rs = null;
    Map<String, String> filters = new LinkedHashMap<String, String>();

    try {
        rs = ps.executeQuery();
        while (rs.next()) {
            String url = rs.getString(1);
            String permission = rs.getString(2);
            filters.put(url, String.format(PERMISSION_STRING, permission));
        }
    } finally {
        JdbcUtils.closeResultSet(rs);
    }

    return filters;
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
@Override
protected AuthenticationInfo doGetAuthenticationInfo(
		AuthenticationToken token) throws AuthenticationException {

	Connection conn = null;
	try {
		conn = dataSource.getConnection();
		if (conn.isClosed())
			initializeDB();

	} catch (Exception e) {
		try {
			initializeDB();
		} catch (Exception ex) {
			Logger.logErr("RoleSecurityJDBCRealm could not re-init DB.", ex);
		}
	} finally {
		JdbcUtils.closeConnection(conn);
		conn = null;
	}

	return super.doGetAuthenticationInfo(token);
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
private int getUserIdFromUserName(Connection conn, String username)
		throws SQLException {
	PreparedStatement ps = null;
	ResultSet rs = null;
	int uid = -1;
	try {
		ps = conn.prepareStatement(USER_ID_QUERY);
		ps.setString(1, username);

		// Execute query
		rs = ps.executeQuery();
		rs.next();
		uid = rs.getInt(1);

	} finally {
		JdbcUtils.closeResultSet(rs);
		JdbcUtils.closeStatement(ps);
	}
	return uid;
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
public boolean clearPrincipalCacheForUser(String username) {
	Connection conn = null;
	try {
		conn = dataSource.getConnection();
		if (conn.isClosed())
			initializeDB();

		int userid = getUserIdFromUserName(conn, username);
		cachedPermissions.remove(String.valueOf(userid));

	} catch (Exception e) {
		try {
			initializeDB();
		} catch (Exception ex) {
			Logger.logErr("RoleSecurityJDBCRealm could not re-init DB.", ex);
		}
	} finally {
		JdbcUtils.closeConnection(conn);
		conn = null;
	}

	return true;

}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
@Override
public AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

    //null usernames are invalid
    if (principals == null) {
        throw new OAuth2AuthenticationException("PrincipalCollection method argument cannot be null.");
    }

    String username = (String) getAvailablePrincipal(principals);

    Connection conn = null;
    Set<String> roleNames = null;
    Set<String> permissions = null;
    try {
        conn = dataSource.getConnection();

        // Retrieve roles and permissions from database
        roleNames = getRoleNamesForUser(conn, username);
        if (permissionsLookupEnabled) {
            permissions = getPermissions(conn, username, roleNames);
        }

    } catch (SQLException e) {
        final String message = "There was a SQL error while authorizing user [" + username + "]";
        if (LOG.isErrorEnabled()) {
            LOG.error(message, e);
        }

        // Rethrow any SQL errors as an authorization exception
        throw new OAuth2AuthenticationException(message, e);
    } finally {
        JdbcUtils.closeConnection(conn);
    }

    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roleNames);
    info.setStringPermissions(permissions);
    return info;

}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
@Override
public AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

    //null usernames are invalid
    if (principals == null) {
        throw new OAuth2AuthenticationException("PrincipalCollection method argument cannot be null.");
    }

    String username = (String) getAvailablePrincipal(principals);

    Connection conn = null;
    Set<String> roleNames = null;
    Set<String> permissions = null;
    try {
        conn = dataSource.getConnection();

        // Retrieve roles and permissions from database
        roleNames = getRoleNamesForUser(conn, username);
        if (permissionsLookupEnabled) {
            permissions = getPermissions(conn, username, roleNames);
        }

    } catch (SQLException e) {
        final String message = "There was a SQL error while authorizing user [" + username + "]";
        if (log.isErrorEnabled()) {
            log.error(message, e);
        }

        // Rethrow any SQL errors as an authorization exception
        throw new OAuth2AuthenticationException(message, e);
    } finally {
        JdbcUtils.closeConnection(conn);
    }

    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roleNames);
    info.setStringPermissions(permissions);
    return info;

}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
/**
 * This implementation of the interface expects the principals collection to return a String username keyed off of
 * this realm's {@link #getName() name}
 *
 * @see #getAuthorizationInfo(org.apache.shiro.subject.PrincipalCollection)
 */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

    //null usernames are invalid
    if (principals == null) {
        throw new AuthorizationException("PrincipalCollection method argument cannot be null.");
    }

    String username = (String) getAvailablePrincipal(principals);

    Connection conn = null;
    Set<String> roleNames = null;
    Set<String> permissions = null;
    try {
        conn = dataSource.getConnection();

        // Retrieve roles and permissions from database
        roleNames = getRoleNamesForUser(conn, username);
        if (permissionsLookupEnabled) {
            permissions = getPermissions(conn, username, roleNames);
        }

    } catch (SQLException e) {
        final String message = "There was a SQL error while authorizing user [" + username + "]";
        if (log.isErrorEnabled()) {
            log.error(message, e);
        }

        // Rethrow any SQL errors as an authorization exception
        throw new AuthorizationException(message, e);
    } finally {
        JdbcUtils.closeConnection(conn);
    }

    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roleNames);
    info.setStringPermissions(permissions);
    return info;

}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
protected Set<String> getRoleNamesForUser(Connection conn, String username) throws SQLException {
    PreparedStatement ps = null;
    ResultSet rs = null;
    Set<String> roleNames = new LinkedHashSet<String>();
    try {
        ps = conn.prepareStatement(userRolesQuery);
        ps.setString(1, username);

        // Execute query
        rs = ps.executeQuery();

        // Loop over results and add each returned role to a set
        while (rs.next()) {

            String roleName = rs.getString(1);

            // Add the role to the list of names if it isn't null
            if (roleName != null) {
                roleNames.add(roleName);
            } else {
                if (log.isWarnEnabled()) {
                    log.warn("Null role name found while retrieving role names for user [" + username + "]");
                }
            }
        }
    } finally {
        JdbcUtils.closeResultSet(rs);
        JdbcUtils.closeStatement(ps);
    }
    return roleNames;
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
protected Set<String> getPermissions(Connection conn, String username, Collection<String> roleNames) throws SQLException {
    PreparedStatement ps = null;
    Set<String> permissions = new LinkedHashSet<String>();
    try {
        ps = conn.prepareStatement(permissionsQuery);
        for (String roleName : roleNames) {

            ps.setString(1, roleName);

            ResultSet rs = null;

            try {
                // Execute query
                rs = ps.executeQuery();

                // Loop over results and add each returned role to a set
                while (rs.next()) {

                    String permissionString = rs.getString(1);

                    // Add the permission to the set of permissions
                    permissions.add(permissionString);
                }
            } finally {
                JdbcUtils.closeResultSet(rs);
            }

        }
    } finally {
        JdbcUtils.closeStatement(ps);
    }

    return permissions;
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
protected Set<String> getRoleNamesForUser(Connection conn, String username)
		throws SQLException {
	PreparedStatement ps = null;
	ResultSet rs = null;
	Set<String> roleNames = new LinkedHashSet<String>();
	try {
		ps = conn.prepareStatement(userRolesQuery);
		ps.setString(1, username);

		// Execute query
		rs = ps.executeQuery();

		// Loop over results and add each returned role to a set
		while (rs.next()) {

			String roleName = rs.getString(1);

			// Add the role to the list of names if it isn't null
			if (roleName != null) {
				roleNames.add(roleName);
			} else {
				if (log.isWarnEnabled()) {
					log.warn("Null role name found while retrieving role names for user ["
							+ username + "]");
				}
			}
		}
	} finally {
		JdbcUtils.closeResultSet(rs);
		JdbcUtils.closeStatement(ps);
	}
	return roleNames;
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String username = upToken.getUsername();

        // Null username is invalid
        if (username == null) {
            throw new AccountException("Null usernames are not allowed by this realm.");
        }

        Connection conn = null;
        SimpleAuthenticationInfo info = null;
        try {
            conn = dataSource.getConnection();

            String password = null;
            String salt = null;
            switch (saltStyle) {
            case NO_SALT:
                password = getPasswordForUser(conn, username)[0];
                break;
            case CRYPT:
                // TODO: separate password and hash from getPasswordForUser[0]
                throw new ConfigurationException("Not implemented yet");
                //break;
            case COLUMN:
                String[] queryResults = getPasswordForUser(conn, username);
                password = queryResults[0];
                salt = queryResults[1];
                break;
            case EXTERNAL:
                password = getPasswordForUser(conn, username)[0];
                salt = getSaltForUser(username);
            }

            if (password == null) {
                throw new UnknownAccountException("No account found for user [" + username + "]");
            }

            info = new SimpleAuthenticationInfo(username, password.toCharArray(), getName());
            
            if (salt != null) {
                info.setCredentialsSalt(ByteSource.Util.bytes(salt));
            }

        } catch (SQLException e) {
            final String message = "There was a SQL error while authenticating user [" + username + "]";
            if (log.isErrorEnabled()) {
                log.error(message, e);
            }

            // Rethrow any SQL errors as an authentication exception
            throw new AuthenticationException(message, e);
        } finally {
            JdbcUtils.closeConnection(conn);
        }

        return info;
    }
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
private String[] getPasswordForUser(Connection conn, String username) throws SQLException {

        String[] result;
        boolean returningSeparatedSalt = false;
        switch (saltStyle) {
        case NO_SALT:
        case CRYPT:
        case EXTERNAL:
            result = new String[1];
            break;
        default:
            result = new String[2];
            returningSeparatedSalt = true;
        }
        
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(authenticationQuery);
            ps.setString(1, username);

            // Execute query
            rs = ps.executeQuery();

            // Loop over results - although we are only expecting one result, since usernames should be unique
            boolean foundResult = false;
            while (rs.next()) {

                // Check to ensure only one row is processed
                if (foundResult) {
                    throw new AuthenticationException("More than one user row found for user [" + username + "]. Usernames must be unique.");
                }

                result[0] = rs.getString(1);
                if (returningSeparatedSalt) {
                    result[1] = rs.getString(2);
                }

                foundResult = true;
            }
        } finally {
            JdbcUtils.closeResultSet(rs);
            JdbcUtils.closeStatement(ps);
        }

        return result;
    }
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
private String[] getPasswordForUser(Connection conn, String username) throws SQLException {
    String[] result;
    boolean returningSeparatedSalt = false;
    switch (saltStyle) {
    case NO_SALT:
    case CRYPT:
    case EXTERNAL:
        result = new String[1];
        break;
    default:
        result = new String[2];
        returningSeparatedSalt = true;
    }
    
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        ps = conn.prepareStatement(authenticationQuery);
        ps.setString(1, username);

        // Execute query
        rs = ps.executeQuery();

        // Loop over results - although we are only expecting one result, since usernames should be unique
        boolean foundResult = false;
        while (rs.next()) {

            // Check to ensure only one row is processed
            if (foundResult) {
                throw new AuthenticationException("More than one user row found for user [" + username + "]. Usernames must be unique.");
            }

            result[0] = rs.getString(1);
            if (returningSeparatedSalt) {
                result[1] = rs.getString(2);
            }

            foundResult = true;
        }
    } finally {
        JdbcUtils.closeResultSet(rs);
        JdbcUtils.closeStatement(ps);
    }

    return result;
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
private String[] getPasswordForUser(Connection conn, String email)
    throws SQLException {
  String[] result;
  boolean returningSeparatedSalt = false;
  switch (saltStyle) {
  case NO_SALT:
  case CRYPT:
  case EXTERNAL:
    result = new String[1];
    break;
  default:
    result = new String[2];
    returningSeparatedSalt = true;
  }

  PreparedStatement ps = null;
  ResultSet rs = null;
  try {
    ps = conn.prepareStatement(authenticationQuery);
    ps.setString(1, email); // set email address

    // Loop over results - although we are only expecting one result,
    // since usernames should be unique
    rs = ps.executeQuery();
    boolean foundResult = false;
    while (rs.next()) {
      // Check to ensure only one row is processed
      if (foundResult) {
        throw new AuthenticationException(
            "More than one user row found for user [" + email
                + "]. Emails must be unique.");
      }

      result[0] = rs.getString(1);
      if (returningSeparatedSalt) {
        result[1] = rs.getString(2);
      }
      foundResult = true;
    }
  } finally {
    JdbcUtils.closeResultSet(rs);
    JdbcUtils.closeStatement(ps);
  }

  return result;
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
@Override
protected AuthorizationInfo doGetAuthorizationInfo(
		PrincipalCollection principals) {
	// TODO Auto-generated method stub

	// null usernames are invalid
	if (principals == null) {
		throw new AuthorizationException(
				"RoleSecurityJdbcRealm.doGetAuthorizationInfo: PrincipalCollection method argument cannot be null.");
	}

	String username = (String) getAvailablePrincipal(principals);

	Connection conn = null;
	Set<String> roleNames = null;
	Set<String> permissions = null;
	try {
		conn = dataSource.getConnection();
		// Retrieve roles and permissions from database

		int userid = getUserIdFromUserName(conn, username);

		roleNames = getRoleNamesForUser(conn, String.valueOf(userid));
		if (permissionsLookupEnabled && roleNames.size() > 0) {
			permissions = getPermissions(conn, String.valueOf(userid),
					roleNames);
		}
		conn.close();
		conn = null;
	} catch (Exception e) {
		final String message = "RoleSecurityJdbcRealm.doGetAuthorizationInfo: There was a SQL error while authorizing user ["
				+ username + "]";

		JdbcUtils.closeConnection(conn);
		// Rethrow any SQL exceptions wrapped so they dont need to be
		// defined in throws
		throw new RuntimeException(e);
	} finally {
		JdbcUtils.closeConnection(conn);
		conn = null;
	}

	SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roleNames);
	info.setStringPermissions(permissions);
	return info;
	// return super.doGetAuthorizationInfo(arg0);
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
private String[] getPasswordForUser(Connection conn, String username)
		throws SQLException {

	String[] result;
	boolean returningSeparatedSalt = false;
	switch (saltStyle) {
	case NO_SALT:
	case CRYPT:
	case EXTERNAL:
		result = new String[1];
		break;
	default:
		result = new String[2];
		returningSeparatedSalt = true;
	}

	PreparedStatement ps = null;
	ResultSet rs = null;
	try {
		ps = conn.prepareStatement(authenticationQuery);
		ps.setString(1, username);

		// Execute query
		rs = ps.executeQuery();

		// Loop over results - although we are only expecting one result,
		// since usernames should be unique
		boolean foundResult = false;
		while (rs.next()) {

			// Check to ensure only one row is processed
			if (foundResult) {
				throw new AuthenticationException(
						"More than one user row found for user ["
								+ username + "]. Usernames must be unique.");
			}

			result[0] = rs.getString(1);
			if (returningSeparatedSalt) {
				result[1] = rs.getString(2);
			}

			foundResult = true;
		}
	} finally {
		JdbcUtils.closeResultSet(rs);
		JdbcUtils.closeStatement(ps);
	}

	return result;
}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
/**
 * This implementation of the interface expects the principals collection to
 * return a String username keyed off of
 * this realm's {@link #getName() name}
 * 
 * @see #getAuthorizationInfo(org.apache.shiro.subject.PrincipalCollection)
 */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(
		PrincipalCollection principals) {

	// null usernames are invalid
	if (principals == null) {
		throw new AuthorizationException(
				"PrincipalCollection method argument cannot be null.");
	}

	String username = (String) getAvailablePrincipal(principals);

	Connection conn = null;
	Set<String> roleNames = null;
	Set<String> permissions = null;
	try {
		conn = dataSource.getConnection();

		// Retrieve roles and permissions from database
		roleNames = getRoleNamesForUser(conn, username);
		if (permissionsLookupEnabled) {
			permissions = getPermissions(conn, username, roleNames);
		}

	} catch (SQLException e) {
		final String message = "There was a SQL error while authorizing user ["
				+ username + "]";
		if (log.isErrorEnabled()) {
			log.error(message, e);
		}

		// Rethrow any SQL errors as an authorization exception
		throw new AuthorizationException(message, e);
	} finally {
		JdbcUtils.closeConnection(conn);
	}

	SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roleNames);
	info.setStringPermissions(permissions);
	return info;

}
 

import org.apache.shiro.util.JdbcUtils; //导入依赖的package包/类
/**
 * refactored this to perform a single query -- much more performant
 * 
 * @param conn
 * @param username
 * @param roleNames
 * @return
 * @throws SQLException
 */
protected Set<String> getPermissions(Connection conn, String username,
		Collection<String> roleNames) throws SQLException {

	if (cachedPermissions.get(username) != null) {
		System.out.println("JdbcRealm permissions cache hit for: "
				+ username);
		return (Set) cachedPermissions.get(username);
	}
	PreparedStatement ps = null;
	Set<String> permissions = new LinkedHashSet<String>();
	try {
		String roleNamex = "";
		for (String roleName : roleNames) {
			roleNamex += "'" + roleName + "',";
		}
		roleNamex = roleNamex.substring(0, roleNamex.length() - 1); // strip
																	// final
																	// comma
		roleNamex += ")";
		ps = conn.prepareStatement(permissionsQuery + roleNamex);

		// ps.setString(1, roleNamex);

		ResultSet rs = null;

		try {
			// Execute query
			rs = ps.executeQuery();

			// Loop over results and add each returned role to a set
			while (rs.next()) {

				String permissionString = rs.getString(1);

				// Add the permission to the set of permissions
				permissions.add(permissionString);
			}
		} finally {
			JdbcUtils.closeResultSet(rs);
		}

	} finally {
		JdbcUtils.closeStatement(ps);
	}

	cachedPermissions.put(username, permissions);
	return permissions;
}