Non, il n'est pas possible de marquer la classe comme «synchronized».
La seule chose que vous puissiez faire est le suivant: un extrait de
l'interface de votre classe et l'utilisation de sollicitation de Proxy
API. Exemple:

class A {
public void m1() {...}
public int m2() {...}
}

A a = new A();
a.m2();
a.m1();


Tout d'abord, vous devez vous débarrasser de constructeur appel. Il
devrait être remplacé par une factory. Si les travaux en Eclipse, il
est un refactoring dénommé «Introduire Facotry...». Vous aurez une
nouvelle méthode

public static A create() {
creturn new A();
}

l'expression «new A()" sera remplacé par le factory appel de méthode:

A a = A.create();

Revenez à votre classe A et d'appliquer refacotring 'Extract
interface...'. Appelez cette nouvelle interface IA et sélectionnez
toutes les méthodes (m1 et m2 dans notre cas) à extraire. À noter que,
factory méthode renvoie interface IA et non A. Il est temps de créer
simplement de sollicitation de proxy handler. Il sera juste en avant
une interface appel à la cible exemple. Créer une nouvelle classe
appelée ProxyHandler:

public class ProxyHandler implements InvocationHandler {

***Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO: Implement method
return null;
}

}

Cette procuration doit transmettre la demande à l'interface certains
cas. Je déclare que l'exemple, comme un domaine dans cette classe et
de créer un appopriate constructeur:

public class ProxyHandler implements InvocationHandler {

protected final Object itsTarget;

public ProxyHandler(Object target) {
this.itsTarget = target;
}

***Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO: Implement method
return null;
}

}

Ensuite, appliquer la méthode invoke:

***Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
return method.invoke(itsTarget, args);
}

Mais nous devrions créer une proxy en quelque sorte. Utilisation
itsTarget field, nous pouvons créer une proxy pour toutes les
interfaces mises en œuvre par sa classe. La méthode suivante devrait
être ajoutée à la classe ProxyHandler:

public Object newProxy() {
Class<?> targetClass = itsTarget.getClass();
ClassLoader classLoader = targetClass.getClassLoader();
Class<?>[] interfaces = targetClass.getInterfaces();
Object proxy = Proxy.newProxyInstance(classLoader, interfaces,
this);
return proxy;
}

Et enfin méthode de mise à jour facotry. Maintenant, au lieu de
renvoyer nouvelle instance d'une classe, nous allons créer de proxy
handler et un nouveau proxy:

public static IA create() {
IA target = new A();
IA proxy = (IA) new ProxyHandler(target).newProxy();
return proxy;
}

Si vous créez simple diagramme de séquence alors vous informer que les
flux

B (A.m1)-> A

a été changé à

B (IA.m1)-> Proxy (invoke)-> ProxyHandler (IA.m1)-> A

Vous verrez pas de différence sauf si vous changez la méthode
'invoke'. Pour rendre l'interface méthodes synchronisées nous devrions
le mettre à jour de la manière suivante:

***Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
synchronized(itsTarget) {
return method.invoke(itsTarget, args);
}
}

Sorry for my pour french and let me know if you need complete
sources.


On 17 juil, 15:51, ToOmS <thomas_esco...***yahoo.fr> wrote:
> Bonjour,
>
> Une toute question, SVP : peut-on déclarer globalement une classe
> "synchronized" lorsque toutes ses méthodes le sont. Et ainsi retirer
> les mot-clefs "synchronized" de ces méthodes ?
>
> Merci d'avance