Discussion :

[L'aigle de Carthage]

Salut à tous,

J'ai deux classes java qui utilisent les annotations:

1ère classe: Transactional.java

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
import javax.enterprise.inject.Default;
import javax.enterprise.util.Nonbinding;
import javax.interceptor.InterceptorBinding;
 
@InterceptorBinding
@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Transactional
{
  @Nonbinding Class<?> qualifier() default Default.class;
}

2 ème classe: TransactionalInterceptor.java

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
import java.io.Serializable;
import java.util.logging.Level;
import java.util.logging.Logger;
 
import javax.inject.Inject;
import javax.interceptor.AroundInvoke;
import javax.interceptor.InvocationContext;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
 
import net.wessendorf.logger.JulFactory;
 
/**
 * AOP via Java EE - (very) simple Interceptor
 * to use (declarative) Transactions via a custom
 * <code>Transactional</code> annotation, like you
 * know from Spring Framework.
 *
 * @author Apache OpenWebBeans team (reservation example)
 */
@Transactional
@javax.interceptor.Interceptor
public class TransactionalInterceptor implements Serializable
{
  private static final long serialVersionUID = 1L;
 
  private @Inject EntityManager entityManager;
  private static Logger LOG = JulFactory.createLogger(TransactionalInterceptor.class);
 
  @AroundInvoke
  public Object invoke(InvocationContext context) throws Exception
  {
    EntityTransaction transaction = entityManager.getTransaction();
 
    try
    {
      if (!transaction.isActive())
      {
        transaction.begin();
      }
 
      return context.proceed();
 
    }
    catch (Exception e)
    {
      LOG.log(Level.SEVERE, "Exception in transactional method call", e);
 
      if (transaction != null)
      {
        transaction.rollback();
      }
 
      throw e;
 
    }
    finally
    {
      if (transaction != null && transaction.isActive())
      {
        transaction.commit();
      }
    }
  }
}

Honnetement, j'ai rien compris de ces 2 classes...
Pouvez vous m'expliquer que font ces deux classes?

Merci pour votre aide d'avance !

[L'aigle de Carthage]

Dans la première classe, j'ai pas vu une déclaration pareille:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public @interface Transactional

c'est bizarre,nn?

[tchize_]

La première classe n'est pas une classe, c'est la déclaration d'une annotation, appelée @Transactionnal. Son but est indiqué dans la javadoc du deuxième code.

La seconde est un interceptor AOP associé à l'annotation, qui gère une transaction autour des méthodes annotées @Transactionnal.

[L'aigle de Carthage]

Merci pour votre réponse, pouvez vous m'expliquer de plus la deuxième classe ?

Il y a aussi cette classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
import java.util.logging.Logger;
 
/**
 * Simple Factory to create a JUL <code>Logger</code>.
 */
public final class JulFactory
{
 
  private JulFactory()
  {
  }
 
  public static Logger createLogger(Class<?> c)
  {
    return createLogger(c.getName());
  }
 
  private static Logger createLogger(String name) 
  {
    return Logger.getLogger(name);
  }
}

Je pense qu'elle sert popur générer du LOG, nn?

[tchize_]

Je vois pas quoi expliquer en plus. C'est un intercepteur utilisé par l'aop. Quand à la dernière classe, c'est deux méthodes statiques d'une ligne, je vois pas ce que vous y comprenez pas. Si vous débutez en java, commencez par les cours avant d'essayer de comprendre des trucs tordus comme l'AOP