Classloading

[Giuliano Mega <megag@xxxxxxxxxxxx>]

    Oi, pessoal,

    Toda vez que leio aquele artigo do Liang e do Bracha, fico confuso 
com uma coisa.
    Eles propõem lá aquela solução pro problema da segurança dos tipos 
que é baseada na imposição de restrições que atuam no momento da carga 
de classe, motivada pela seguinte frase (seção 4.2.1):

    "A straightforward solution to the type-safety problem is to 
uniformly use both the class's name and its defining loader to represent 
a class type (...). The only way to determine the defining loader, 
however, is to actually load the class through the initiating loader. 
(...) The shortcoming of this approach is that is sacrifices lazy class 
loading".

    Daí eu sempre fico aqui pensando... caramba, as restrições na hora 
da carga da classe de fato resolvem o problema, mas não seria mais 
natural implantar tipos "dinâmicos" e inserir uma restrição simplona de 
tipagem nas referências? Vou me explicar melhor:

    Suponha que uma classe A declara um campo (ou variável local, dentro 
de um método mesmo) de uma classe C1. Se a classe A é carregada com o 
classloader L1, então a JVM passa a enxergar a classe A como sendo do 
tipo "dinâmico" (A,L1), marcando a referência à classe C1, presente na 
classe A, como sendo do tipo "dinâmico" (C1,L1).  Vou até pegar o 
exemplo do artigo:


    class <A, L1){
       void f(){
          <C1, L1>x = <B, L2>.g();
       }
    }

    class <B, L2>{
       <C1, L2> g() {...}
    }
   
    Bem, daí o código de A faz uma referência à classe B que, por 
malícia, é delegada por L1 ao loader L2. O loader L2 carrega a classe B 
e encontra nela uma referência ao texto da classe C1 e a carrega. O tipo 
dinâmico da referência retornada pelo método G passa a ser <C1, L2>. 
Quando o código malicioso tenta atribuir a uma referência do tipo 
dinâmico <C1, L1> um objeto do tipo dinâmico <C1, L2>, ele toma um 
ClassCastException.

    Pronto, acabo de reforçar a segurança de tipos sem perder o lazy 
loading e nem usar classloading constraints. A única desvantagem, me 
parece, é que vai ter de rolar uma checagem de tipos em tempo de 
execução, o que pode ir contra a filosofia de que toda e qualquer 
checagem tem de ser feita até o momento de carga da classe - depois 
disso, você não pode checar mais nada.

    Bem, se alguém puder me ajudar com essa dúvida, eu agradeço.

       Um abraço,

          Giuliano