Fórum Permissão com Reflection #498282
18/10/2014
0
Estou usando anotações para definir ou não eu tenho permissão usar o método anota, porem quando essa classe tem um construtor onde iniciar alguma variável apresenta um erro quando é um classe onde não precisar iniciado qualquer variavel executa normal mente.
classe anotada :
Interface da classe :
Classe da Anotacao :
Classe responsável pela sessao :
Classe que implementa a sessao :
Classe que faz a validação da interface :
Classe que faz a verificacao :
Classe que gera as exeption :
Instanciando a classe :
chamando os métodos :
Obs : quando fiz o teste crie uma interface simples onde apenas somava e calcular onde eu não inicio nenhuma variável no construtor.
classe anotada :
public class TipoFinanciamentoControle implements InterfaceControle<TipoFinanciamento> {
private static final long serialVersionUID = 1L;
private final TipoFinanciamentoDao dao = new TipoFinanciamentoDao();;
public TipoFinanciamentoControle() {
dao = new TipoFinanciamentoDao();
}
@Override
@NecessitaPermissao("incluir")
public TipoFinanciamento incluir(TipoFinanciamento obj) {
return dao.incluir(obj);
}
Interface da classe :
public interface InterfaceControle<T> {
T incluir(T obj);
T alterar(T obj);
boolean remover(T obj);
T get(int id);
List<T> getAll();
List<T> getByName(String name);
}
Classe da Anotacao :
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface NecessitaPermissao {
String value();
}
Classe responsável pela sessao :
public abstract class Sessao {
private static Sessao sessao;
private static Class<? extends Sessao> sessaoClass;
public static Class<? extends Sessao> getSessaoClass() {
return sessaoClass;
}
public static void setSessaoClass(Class<? extends Sessao> sessaoClass) {
Sessao.sessaoClass = sessaoClass;
}
public abstract boolean isIniciado();
public abstract void logar(Usuario usr) throws Exception;
public abstract void efetuarLogoff(String login, String senha) throws Exception;
public abstract boolean verificarTemAcesso(String acao);
public abstract boolean verificarNecessitaDaPermissaoDoGerente(String acao);
public abstract boolean solicitarAutorizacaoGerente(String acao) throws Exception;
public synchronized static Sessao getInstance() {
if (sessao == null) {
try {
sessao = sessaoClass.newInstance();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
return sessao;
}
}
Classe que implementa a sessao :
public class SessaoImpl extends Sessao{
private static SessaoImpl sessao;
private static Usuario usr;
public SessaoImpl() {
}
static{
Sessao.setSessaoClass(SessaoImpl.class);
}
public Usuario getUsuario(){
return usr;
}
@Override
public boolean isIniciado() {
return (usr!=null);
}
@Override
public void efetuarLogoff(String login, String senha) throws Exception {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
@Override
public boolean verificarTemAcesso(String acao ) {
for(Permissao permissao :usr.getPermissoes()){
if(permissao.getAcao().equals(acao)){
return true;
}
}
return false;
}
@Override
public boolean verificarNecessitaDaPermissaoDoGerente(String acao) {
for(Permissao permissao :usr.getPermissoes()){
if(permissao.getAcao().equals(acao)){
return permissao.isSenhaGerencial();
}
}
return false;
}
@Override
public boolean solicitarAutorizacaoGerente(String acao) throws Exception {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
@Override
public void logar(Usuario usuario) throws Exception {
usr = usuario;
if (usr!=null) {
// criarUsuarioFicticio();
return;
}
throw new AcessoNaoPermitido("Autenticacao invalida !");
}
Classe que faz a validação da interface :
public class SecureBeanFactory {
private static final Logger logger
= Logger.getLogger(SecureBeanFactory.class.getName());
static {
logger.setLevel(Level.OFF);
}
public static <T> T createSecureBean(Class<T> classeInterface
, Object classeConcreta, List<Verificacao> verificacoesAdicionais) {
InvocationHandler handler = new SecureBeanInvocationHandler(
classeConcreta, verificacoesAdicionais);
Class[] interfaces = new Class[];
T proxy = (T) Proxy.newProxyInstance(classeConcreta.getClass()
.getClassLoader(), interfaces, handler);
return proxy;
}
public static <T> T createSecureBean(Class<T> classeInterface
, Object classeConcreta) {
return createSecureBean(classeInterface, classeConcreta, null);
}
private static class SecureBeanInvocationHandler<T>
implements InvocationHandler {
private T concreteBean;
private List<Verificacao> verificacoesAdicionais;
public SecureBeanInvocationHandler(T concreteBean) {
this.concreteBean = concreteBean;
}
public SecureBeanInvocationHandler(T concreteBean, List<Verificacao> verificacoesAdicionais) {
this.concreteBean = concreteBean;
this.verificacoesAdicionais = verificacoesAdicionais;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// obtem o metodo da classe concreta
Object retorno = null;
Method methodConcreto = concreteBean.getClass()
.getMethod(method.getName(), method.getParameterTypes());
// verifica se o metodo necessida de permissao
for (Annotation a : methodConcreto.getAnnotations()) {
// System.out.println("annotation: " + a);
if (a instanceof NecessitaPermissao) {
NecessitaPermissao np = (NecessitaPermissao) a;
verificarPermissao(np.value());
}
}
// Verifica as interfaces
for (Class i : proxy.getClass().getInterfaces()) {
methodConcreto = i.getMethod(method.getName(), method.getParameterTypes());
if (methodConcreto == null) continue;
// verifica se o metodo pode ser acessado de acordo com o ciclo de vida
if (methodConcreto.isAnnotationPresent(NecessitaPermissao.class)) {
NecessitaPermissao np = methodConcreto.getAnnotation(NecessitaPermissao.class);
verificarPermissao(np.value());
}
}
// retorno
retorno = methodConcreto.invoke(concreteBean, args);
return retorno;
}
private void verificarPermissao(String acao) throws Exception {
logger.log(Level.INFO, "Verificando permissao para ... ", acao);
Sessao sessao = Sessao.getInstance();
if (sessao==null || !sessao.isIniciado()) {
throw new AcessoNaoPermitido("Sessao nao iniciado !");
}
if (!sessao.verificarTemAcesso(acao)) {
logger.log(Level.INFO
, "Permissao para ACESSO NAO AUTORIZADO ... ", acao);
throw new AcessoNaoPermitido(
"Acesso nao permitido !");
}
logger.log(Level.INFO, "Permissao para OK ... ", acao);
logger.log(Level.INFO
, "Realizando verificacoes adicionais ... ",acao);
if (verificacoesAdicionais != null) {
for (Verificacao v : verificacoesAdicionais) {
if (v.isNecessario(acao)) {
if (!v.verificar(acao)) {
throw new AcessoNaoPermitido(
v.getMensagemNaoPermitido());
}
}
}
}
if (sessao.verificarNecessitaDaPermissaoDoGerente(acao)) {
logger.log(Level.INFO
, "Solicitando autorizacao do gerente ... ", acao);
if (sessao.solicitarAutorizacaoGerente(acao)) {
return; // OK
}
else {
logger.log(Level.INFO
, "Autorizacao do gerente invalido ... ", acao);
throw new AcessoNaoPermitido(
"Autorizacao do gerente invalido !");
}
}
}
}
}
Classe que faz a verificacao :
public interface Verificacao {
public boolean isNecessario(String acao);
public boolean verificar(String acao);
public String getMensagemNaoPermitido();
}
Classe que gera as exeption :
public class AcessoNaoPermitido extends Exception{
public AcessoNaoPermitido(String message) {
super(message);
}
Instanciando a classe :
TipoFinanciamentoControle control = new TipoFinanciamentoControle();
InterfaceControle tipo = SecureBeanFactory.createSecureBean(InterfaceControle.class, control);
chamando os métodos :
try {
Class.forName("com.br.emobeli.seguranca.impl.SessaoImpl");
} catch (ClassNotFoundException ex) {
System.err.println(ex.getMessage());
System.exit(-1);
}
Sessao sessao = Sessao.getInstance();
try {
sessao.logar(usr);
} catch (Exception ex) {
System.err.println("logar "+ex.getMessage());
System.exit(-1);
}
// invoca o metodo somar
try {
tipo.incluir(tp);
}
catch (Exception ex) {
UtilMensagens.mensagemErro("erro "+UtilErros.getMensagemErro(ex));
System.err.println("incluir : " + ex.getCause());
System.exit(-1);
}
Obs : quando fiz o teste crie uma interface simples onde apenas somava e calcular onde eu não inicio nenhuma variável no construtor.
John Lima
Curtir tópico
+ 0
Responder
Clique aqui para fazer login e interagir na Comunidade :)