¿Cuáles son las anotaciones de primavera?

Varios paquetes están separados por comas.

1. @Component

@Component

es la forma común de todos los componentes administrados por Spring. La anotación @Component se puede colocar en la cabecera. clase @Component No recomendado.

2. @Controller

@Controller corresponde al Bean de la capa de presentación, que es Action, por ejemplo:

1 @Controller

2 @Scope("prototipo")

3 clase pública UserAction extiende BaseActionlt; {

4 ……

5 }

Después de usar la anotación @Controller para identificar UserAction, significa que UserAction se entregará al contenedor Spring para su administración. Habrá una acción llamada "userAction" en el contenedor Spring. basado en el nombre de la clase UserAction. Nota: Si @Controller no especifica su valor@Controller, el nombre del bean predeterminado es la primera letra del nombre de la clase en minúsculas. Si se especifica value@Controller(value="UserAction") o @Controller("UserAction"), use valor como nombre del frijol.

La UserAction aquí también usa la anotación @Scope. @Scope("prototype") significa declarar el alcance de la Acción como un prototipo. Puede usar el alcance="prototype" del contenedor para garantizar. que cada solicitud tenga una Acción separada para manejar para evitar problemas de seguridad de subprocesos de Acción en struts.

El alcance predeterminado de Spring es el modo singleton (scope="singleton"), que solo crea un objeto de acción. Cada acceso es el mismo objeto de acción, y los datos no son seguros. Struts2 requiere que cada acceso corresponda a una acción y un alcance diferentes. "prototipo" puede garantizar que se cree un objeto de acción cuando hay una solicitud

3 @Service

@Service corresponde al bean de la capa empresarial, por ejemplo:

1 @Service("userService")

2 clase pública UserServiceImpl implementa UserService {

3 ………

4 }

< p La anotación >@Service("userService") le dice a Spring que cuando Spring quiere crear una instancia de UserServiceImpl, el nombre del bean debe llamarse "userService", de modo que cuando Action necesite usar una instancia de UserServiceImpl, pueda crearla. por Spring. "userService" y luego inyectarlo en Action: En Action, solo necesita declarar una variable llamada "userService" para recibir el "userService" inyectado por Spring. El código específico es el siguiente:

<. p>1 // Inyectar servicio de usuario

2 @Resource(nombre = "servicio de usuario")

3 servicio de usuario privado servicio de usuario;

Nota: El tipo de "servicio de usuario "La variable declarada en Acción debe ser "UserServiceImpl" o su clase principal "UserService", de lo contrario no se puede inyectar debido a tipos inconsistentes. Dado que la variable "userService" declarada en Acción está anotada con la anotación @Resource y su nombre = Se especifica "userService", esto significa que es equivalente a decirle a Spring que mi acción quiere crear una instancia de un "userService Spring", apúrate y ayúdame a crear una instancia y luego dármelo cuando Spring vea la anotación @Resource. la variable userService, puede usar el atributo de nombre especificado por ella. Usted sabe que se necesita una instancia de UserServiceImpl en Acción. En este momento, Spring inyectará la instancia de UserServiceImpl que creó llamada "userService" en la variable "userService". en Acción para ayudar a Acción a completar la creación de instancias de userService. De esta manera, en Acción, no es necesario crear una instancia de userService en la forma más primitiva de "UserService userService = new UserServiceImpl();".

Sin Spring, cuando una Acción necesita usar UserServiceImpl, debe crear activamente un objeto de instancia a través de "UserService userService = new UserServiceImpl ();" Sin embargo, después de usar Spring, cuando una Acción necesita usar UserServiceImpl, no es necesario hacerlo activamente. crear una instancia de UserServiceImpl Ahora, la creación de la instancia de UserServiceImpl se ha dejado en manos de Spring y le da la instancia de UserServiceImpl creada a Action, y Action puede usarla directamente. La acción ha cambiado de crear activamente una instancia de UserServiceImpl y poder usarla inmediatamente, a esperar pasivamente a que Spring cree una instancia de UserServiceImpl y luego la inyecte en la Acción antes de que se pueda usar la Acción. Esto muestra que el "control" de Action sobre la clase "UserServiceImpl" se ha "revertido". Resulta que la iniciativa está en sus propias manos. Si desea utilizar una instancia de la clase "UserServiceImpl", puede tomar la iniciativa. para crear una nueva y podrá usarla inmediatamente, pero ahora no puedo tomar la iniciativa de crear una nueva instancia de la clase "UserServiceImpl". El poder de crear una nueva instancia de la clase "UserServiceImpl" me ha sido quitado. Spring solo puede crear una instancia de la clase "UserServiceImpl", y Action solo puede esperar a que Spring la cree. Después de crear una instancia de la clase "UserServiceImpl", "por favor" Spring le proporcione la instancia creada de ". UserServiceImpl" para que pueda usar "UserServiceImpl". Esta es la idea central de Spring "Inversión de control", también llamada "Inyección de dependencia" y "Inyección de dependencia" que también son fáciles de entender. Las acciones deben usar UserServiceImpl. para funcionar, por lo que depende de UserServiceImpl. Spring inyecta (es decir, "da") el UserServiceImpl del que Action debe depender. Esto es lo que se llama "Inyección de dependencia". Para Action, si Action depende de algo, le pedirá a Spring que se lo inyecte. Para Spring, si Action necesita algo, Spring tomará la iniciativa de inyectarlo.

4. @Repository

@Repository corresponde al bean de la capa de acceso a datos, por ejemplo:

1 @Repository(value="userDao")

2 clase pública UserDaoImpl extiende BaseDaoImpllt; {

3 ………

4 }

@Repository(value="userDao" ) la anotación es Dígale a Spring que cree una instancia de UserDaoImpl llamada "userDao".

Cuando el Servicio necesita usar la instancia UserDaoImpl llamada "userDao" creada por Spring, puede usar la anotación @Resource(name = "userDao") para decirle a Spring que Spring inyectará el userDao creado en el Servicio.

1 // Inyecta userDao, que es necesario para recuperar el usuario especificado de la base de datos según el ID de usuario

2 @Resource(name = "userDao")

3 BaseDaolt privado;