Struts2.3.24 + Spring4.1.6 + Hibernate4.3.11 + MySQL5.5.25 Construcción de entorno de desarrollo e instrucciones relacionadas.
1. Objetivo
1. Construya un entorno de desarrollo SSH tradicional y ejecútelo con éxito (inserte, consulta)
2. Comprenda la configuración del grupo de conexión C3P0
3. Comprenda el caché secundario de Hibernate y verifique
4. Comprenda la configuración de las cosas de Spring y verifique
5. Comprenda el COI de la primavera (inyección de dependencia), entregue el objeto de acción (frijoles) de Struts2 al manejo de la primavera, frijoles personalizados, etc., y verifique
6. Comprenda Spring AOP (programación orientada a la sección) y escriba funciones de sección personalizadas para verificar los resultados
2. Preparación
Entorno de desarrollo: Eclipse para Java EE; mysql5.5.25; JDK1.7.0_79; navicat10.1.7 (opcional);
Cree una demostración de la base de datos:
/*Navicat MySQL Data Transfersource Server: Localhost_3306Source Versión del servidor: 50519 Host: Localhost: 3306Source Base de datos: Servidor DemoTarget Tipo: MySQLTarget Versión del servidor: 50519 File Coding: 65001 Date: 2016-01-09 23: 36: 02*/set retting upsionals = 0;-0;-0;-0;-0;-0;-0; ----------------------- Charset = utf8;
Crear un nuevo proyecto web, la estructura del directorio es la siguiente:
Prepare el paquete JAR y colóquelo en el directorio web-Inf lib (si está interesado, puede usar Maven para administrar el proceso, pero a veces es muy lento descargar el paquete JAR ...)
Los paquetes JAR relacionados se pueden encontrar en los puntales descargados, la primavera y la hibernación. Aquí hay una referencia. Algunos de ellos se pueden eliminar, como los paquetes JAR en la parte de MVC de primavera:
3. Configurar web.xml
Configure un filtro Struts2 para mapear todas las solicitudes *.Action, y es manejado por el objeto StrutsPrepareAnDexCuteFilter;
Configure el parámetro de param contextual y especifique la ruta del archivo de configuración de Spring. Los parámetros en <context-param> se pueden obtener utilizando servletContext.getInitParameter ("param-name");
Configuración del oyente es principalmente para leer la información del archivo de configuración ApplicationContext.xml, crear frijoles y otros trabajos de inicialización;
<? xml versión = "1.0" encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" " xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" <Spant-Name> SSH </spant-Name> <filter> <filter-name> struts2 </filter-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.strutsprepareAndexeCuteFilter </filter-class> </filter> <filter-mapping> <filter-name> struts2 </filtre-name> <Url-Pattern>*. Action </sl-Pattern> </filter-mapping> <context-param> <amamname> contextConfigLocation </amamname> <amam-value> classpath: applicationContext.xml </param-value> </context-param> <IARDER> <Oyerer-class> org.springframework.web.context.contextlogloaderListener </oyer-class> </oyeyer> <welcome-file-list> <call welcome-file> index.jsp </welcome-file> </welcome-file-list> </web-app>
4. Configurar ApplicationContext.xml
Configure el escaneo automático de @Repostory, @Service y otras anotaciones en el paquete SSH y genere frijoles correspondientes;
Configurar la fuente de datos (el grupo de conexión JDBC es C3P0, puede consultar la configuración detallada de C3P0). La función principal del grupo de conexión es proporcionar rápidamente la conexión y reutilizarla. No requiere cada destrucción y creación. Requiere la configuración del nombre de usuario, la contraseña, el número máximo de conexiones, el número mínimo de conexiones, el número inicial de conexiones y otros parámetros relacionados;
Configurar sessionFactory (puede consultar la configuración detallada de Hibernate, donde configura para habilitar el caché de nivel 2), la función principal es proporcionar sesión y ejecutar declaraciones SQL; Aquí usaremos HibernateTemplate para operar la base de datos para facilitar el control físico de la primavera; PD, la asignación entre clases y tablas de base de datos también debe configurarse en la configuración de Hibernate;
Configure el Bean de Transaction Manager como HibernateTransactionManager e inicialice el atributo de miembro del miembro SessionFactory en el sessionFactory Bean configurado anteriormente;
Configure las características de propagación de la transacción y configure una sección para referirse a ella, y realice el control de la transacción de todos los métodos ADD, Eliminar, actualizar y guardar métodos en todos los paquetes y subpackages ssh.service. También puede configurar el comportamiento de propagación de transacciones y otros parámetros;
Finalmente, hay una configuración personalizada relacionada con AOP, que aplica la sección personalizada 'MYAOP' para controlar todos los métodos que comienzan con las pruebas en ssh.aop.aoptest, y los resultados se verificarán más adelante;
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: p = "http://www.springframework.org/schema/p" "" "" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: jdbc = "http://www.springframework.org/schema/jdbc" xsi: schemalocation = "http://wwww.springframe http://www.springframework.org/schema/Beans http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd http://www.springframework.org/schema/context/spring-context-4.1.xsd "> <!-escanea el classpath para componentes anotados (incluido @Repostory y @service que se registrará como beans de primavera-> <contexto: componente-scan-package =" ssh "/> <!-; name = "dataSource" destruye-method = "Close"> <Property Name = "DriverClass" value = "com.mysql.jdbc.driver" /> <propiedad name = "jdbcurl" valor = "jdbc: mysql: // localhost: 3306 /demo" /> <valor de propiedad = "usuarios de usuario =" raíz " /> <nombre de propiedad =" contraseña "contraseña" Valor "de propiedad" name = "adquireIncrement" value = "1"> </propiety> <Property Name = "InitialPoolSize" Value = "80"> </Property> <Property Name = "MaxidletEtime" valor = "60"> </property> <Property Name = "MaxpoolSize" Value = "80"> </Property> <Name = "MinpoolSize" Value = "30"> </Property> <Nombre de propiedad = "Nombre =" Atrando "PropertyElay. value = "1000"> </Property> <Property name = "adquireretryattempts" value = "60"> </property <propiedad name = "breakafterAcQuiRefailure" value = "false"> </sperties> <!-Si aparecen demasiadas conexiones, someter a la lista de configuración my.ini de mySql para aumentar el número máximo de las conexiones (consulte el comando de conexión actual: someter a la línea de proceso:----show showlist----el archivo de my.ini de mySql para aumentar el número de máximo de las conexiones (consulte el comando de conexión actual: someter a la línea de proceso:----show shelist----el archivo de my.ini de mysql para aumentar el número de máximo de las conexiones (consulte el comando de conexión actual: Show-showlist: id = "SessionFactory"> <Property Name = "DataSource" ref = "DataSource"/> <Property name = "HibernateProperties"> <prop key = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </prop> <prop key = "hibebernate.show_sql"> true </prop> <prop> <prop> <prop> <prop> key="hibernate.hbm2ddl.auto">update</prop> <prop key="current_session_context_class">thread</prop> <prop key="hibernate.cache.use_second_level_cache">true</prop> <prop key="hibernate.cache.use_second_level_cache">true</prop> <prop key = "Hibernate.cache.region.factory_class"> org.hibernate.cache.ehcache.ehcacheregionFactory </prop> <proping key = "hibernate.cache.use_Query_cache"> verdadero </pp> <propir key = "Hibernate.cache.Provider_Configuration_file_resource_path"> ehcache.xml </prop> </prop> </props> </propiets> <Property name = "MapingLocations"> <List> <list> name = "AnnotatedClasses"> <List> <Value> ssh.model.user </value> </list> </property>-> </bean> <!-Configuración del administrador de transacciones-> <bean id = "transaccionManager"> <Property name = "sessionFactory" ref = "sessionory"/> </bean> <!-Características de propagación de transacciones-manager = "Transaction Manager" <tx: "TX:" TX: <TX: ATRITUTOS: ATRITUTOS: ATRIBUTS: <tx: método name = "add*" propagation = "required" read-Only = "false" reversión-for = "java.lang.exception"/> <tx: método name = "delete*" propagation = "requerido" requerido "requerido =" falso "rollback-for =" java.lang.exception "/> <tx: name de método =" actualización*"propagation =" requerido "requerido" requerido "requerido" requerido "requerido" requerido "requerido" " rollback-for="java.lang.Exception"/> <tx:method name="save*" propagation="REQUIRED" read-only="false" rollback-for="java.lang.Exception"/> </tx:attributes> </tx:advice> <aop:config> <aop:pointcut id="pcMethod" expression="execution(* ssh.service ..*.*(..)) "/> <aop: asesor PointCut-ref =" pcmethod "adsorial-ref =" txadvice "/> </aop: config> <!-Custom AOP Processing test-> <bean id =" aOptest "> </bean> <bean id =" myaOp "> </bean> <aop: config proxy-target CLAS <aop: aspecto ref = "myaop"> <aop: pointcut id = "pcmethodtest" expresion = "ejecution (* ssh.aop.aoptest.test* (..))"/> <aop: antes de pointcut-ref = "pcmethodtest" método = "antes"/> <aop: después de pointcut-corm. </aop: aspecto> </aop: config> </le beans>
5. Configurar struts.xml
Configure las estructuras. ObjectFactory constante a resorte, lo que indica que la acción es obtenida por el bean a través del resorte;
Configure el tipo de resultado en "JSON", y también puede configurar otras cosas. Aquí, para la conveniencia de la interacción de datos front-end y de back-end, se configura en formato JSON;
Configurar dos acciones, adduser y QueryAlluser;
<? xml versión = "1.0" encoding = "utf-8"?> <! DocType Struts public "-// Apache Software Foundation // Dtd Struts Configuration 2.3 // en" "http://struts.apache.org/dtds/struts-2.3.dtd"> <truts> <ruts name = "Struts.s.Objectory" valore " name = "struts.enable.dynamicMethodinVocation" valor = "false" /> <constant name = "struts.devmode" valor = "falso" /> <paquete name = "predeterminado" extiende = "struts-default, json-decefault"> <nobal-results> <pla de resultados de resultados = "json"> <param name = "root"> json < /param> <marron name = "ContentType"> Text/Html </amam> </sult> </global-results> <Action name = "addUser" método = "adduser"> <resultado>. </result> </action> <Action name = "QueryAlluser" Method = "QueryAllUser"> <Result>. </sul
6. Escribe código relevante
Notas:
DAO hereda la clase HibernatedaSupport, y todas las operaciones relacionadas con la base de datos son operadas por HibernateTemplate;
Agregue las anotaciones correspondientes a la capa DAO, la capa de servicio y la acción, y regístrese como frijoles de resorte;
El código adjunto es el siguiente:
UserAction.java
paquete ssh.action; import java.io.printwriter; import java.util.list; import javax.annotation.resource; import javax.servlet.http.httpservletrequest; import javax.servlet.http.httpservletResponse; import org.apache.struts2.servletActionContext; import org.springframework.stereotype.controller; import ssh.aop.aoptest; import ssh.model.user; import ssh.service.userService; import com.google.gson.gson; @ControllerPublic Class userAction {logger logger = = Logger.getLogger (userAction.class); @Resource Private UserSerervice UserService; @Resource Private Aoptest Aoptest; public void addUser () {printWriter out = null; Pruebe {httpservletRequest request = servletactionContext.getRequest (); HttpservletResponse respuesta = servletactionContext.getResponse (); respuesta.setContentType ("text/html; charset = utf-8"); Cuenta de cadena = request.getParameter ("cuenta"); Name de cadena = request.getParameter ("nombre"); Dirección de cadena = request.getParameter ("dirección"); Usuario user = nuevo usuario (); user.setAccount (cuenta); user.setaddress (dirección); user.setName (nombre); UserService.Add (usuario); out = respuesta.getWriter (); out.write (new Gson (). Tojson ("éxito")); } catch (Exception e) {E.PrintStackTrace (); logger.error (e.getMessage ()); if (out! = null) out.write (new Gson (). TJson ("Fail")); } finalmente {out.flush (); out.close (); }} public void QueryAlluser () {printWriter out = null; aoptest.test1 (); aoptest.test2 (); //logger.error("i "); intente {httpservletResponse respuesta = servletactionContext.getResponse (); respuesta.setContentType ("text/html; charset = utf-8"); Gson gson = new Gson (); List <Serem> UserList = Userservice.queryAllUser (); Cadena gsonstr = gson.tojson (userList); out = respuesta.getWriter (); out.write (gsonstr); } catch (Exception e) {E.PrintStackTrace (); logger.error (e.getMessage ()); if (out! = null) out.write (new Gson (). TJson ("Fail")); } finalmente {out.flush (); out.close (); }}}Aoptest.java
paquete ssh.aop; public class aoptest {public void test1 () {System.out.println ("El método AopTest Test1 se está ejecutando ~"); } public void test2 () {System.out.println ("El método AOPTest Test2 está ejecutando ~"); }}Myaop.java
paquete ssh.aop; public class myaop {public void antes () {System.out.println ("Borfor ~"); } public void After () {System.out.println ("After ~"); }}Baseo.java
paquete ssh.dao.base; import javax.annotation.resource; import org.hibernate.sessionFactory; import org.springframework.orm.hibernate4.support.HibernAdAsAsupport; sessionfactory de la clase de clase pública { this.setSessionFactory (SessionFactory); }}Userdao.java
paquete ssh.dao; import java.util.arrayList; import java.util.list; import org.springframework.orm.hibernate4.HiberNatetEmplate; import Org.springFrameWork.stereotype.repository; import ssh.dao.base.basedAo; import ssh.model.user; UserDao extiende a BasedAO {public void add (usuario de usuario) {this.gethibernateTemplate (). Guardar (usuario); } @Suppleswarnings ("sin verificar") Lista pública <serem> QueryAlluser () {list <serer> users = new ArrayList <Serem> (); HibernateTemplate hibernateTemplate = this.gethibernateTemplate (); hibernateTemplate.setCachequeries (verdadero); users = (list <serer>) HibernateTemplate.find ("del usuario"); hibernateTemplate.setCachequeries (falso); devolver usuarios; }}User.java
paquete ssh.model; import java.io.serializable; public class User implementa serializable { / ** * * / private static final long SerialVersionUid = -6190571611246371934l; ID de larga prudente; cuenta de cadena privada; nombre de cadena privada; dirección de cadena privada; public String getAcCount () {Cuenta de retorno; } public String getName () {nombre de retorno; } public String getAddress () {Dirección de retorno; } public void setAccount (cuenta de cadena) {this.account = cuenta; } public void setName (nombre de cadena) {this.name = name; } public void setAddress (dirección de cadena) {this.address = dirección; } / ** * @return el id * / public long getId () {return id; } / ** * @param id El id para establecer * / public void setid (id id) {this.id = id; }}User.hbm.xml
<? xml versión = "1.0"?> <!-~ hibernado, persistencia relacional para Java ~ ~ Copyright (C) 2010, Red Hat Inc. o contribuyentes de terceros como ~ indicado por las etiquetas @author o el atributo de copyright express ~ declaraciones aplicadas por los autores. Todas las contribuciones de terceros se distribuyen bajo licencia por Red Hat Inc. ~ ~ Este material con derechos de autor está disponible para cualquier persona que desee usar, modificar, ~ copiar o redistribuirlo sujeto a los términos y condiciones de la Licencia Pública General Gnu ~ menor, como se publica por la Free Software Foundation. ~ ~ Este programa se distribuye con la esperanza de que sea útil, ~ pero sin ninguna garantía; sin siquiera la garantía implícita de comerciabilidad o aptitud para un propósito particular. Consulte la Licencia Pública General Lesser de GNU ~ para obtener más detalles. ~ ~ Debería haber recibido una copia de la Licencia Pública General Lesser de GNU ~ junto con esta distribución; Si no, escriba a: ~ Free Software Foundation, Inc. ~ 51 Franklin Street, Fifth Floor ~ Boston, MA 02110-1301 USA-> <! DOCTYPE Hibernate-Mapping público "-// Hibernate/Hibernate Mapeo DTD 3.0 // EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping paquete =" ssh.model "> <class name =" user "table =" user "> <cache usege =" read-write "/> <id name =" id "columna =" id "> <generador/> <<d> iD> <d>" cuento " type = "java.lang.string" column = "cuenta"/> <propiedad name = "name" type = "java.lang.string" column = "name"/> <propiedad name = "dirección" type = "java.lang.string" columna = "dirección"/> </class> </hibernate-mapping>
Userservice.java
paquete ssh.service; import java.util.list; import javax.annotation.resource; import org.springframework.stereotype.service; import ssh.dao.userdao; import ssh.model.user; @ServicePublic Class UserService {@Resource userdao userdao = new userdao (new UserDao (); Lista pública <seremir> QUERYALLUSER () {return userDao.queryAllUser (); } public void add (usuario de usuario) {userDao.Add (usuario); }}index.jsp (recuerde agregar la biblioteca jQuery)
<%@ page lenguaje = "java" contentType = "text/html; charset = utf-8" pageEncoding = "utf-8"%> <! DocType html público "-// w3c // dtd html 4.01 transición // en" " "http://www.w3.org/tr/html4/loose.dtd"><html><head><meta http-equiv =" content-type "content =" text/html; charset = utf-8 "> <title> title aquí </title> <style> .mt20 {margen-top: 20px;} </ystye> </head> <body> <div style = "text-align: centro;"> <div> <label> cuenta: </etiqueta> <input id = "cuenta" tipo "type =" text "/> </div> <div> <belebelebel> name: </etiqueta> <put id =" name "type" type = "text"/> </div> <div> <label> la dirección: </selictar> <pinte ID = " type = "text"/> </div> <iv> <button id = "adduser"> agregar </botón> </div> <h3> lista de usuarios: </h3> <ul id = "userList"> </ul> <script type = "text/javascript" src = "js/jquery-1.11.1.1.min.js"> </script> <script> $ (function () () Url: 'Queryalluser.Action', Type: 'Post', DataType: 'Json', Success: Function (Data) {try {for (var i = 0; i <data.length; i ++) {$ ("#uslist"). Append ("<li> <span style = 'color: rojo'> id = "+data [i] .id+" </span>, cuenta = "+data [i] .account+", name = "+data [i] .name+", dirección = "+data [i] .address+" </li> "); }} catch (e) {}; }, error: función (e) {alerta ("error sys"); }}); $("#addUser").on("click", function() { var account = $("#account").val(); var name = $("#name").val(); var address = $("#address").val(); $.ajax({ url : 'addUser.action', type : 'post', dataType : 'json', data : { account : account, name : name, address : address }, éxito: funciones (datos) {try {$ ("#uslist"). Append ("<li> Account ="+Accounting+","+nombre+", dirección ="+dirección+"</li>") }); }); </script> </body> </html>7. Resultados de verificación
Regrese al principio, comience a familiarizarse con las tecnologías relevantes y verificar los resultados
1. Construya un entorno de desarrollo SSH tradicional y ejecútelo con éxito (inserte, consulta)
La siguiente figura: consulta y agregue usuarios con éxito;
2. Comprenda la configuración del grupo de conexión C3P0
Las conexiones de la base de datos son recursos costosos, y la apertura y el cierre consume rendimiento. Por lo tanto, se pueden gestionar con un grupo de conexión, inicializando varias conexiones y reutilizándolas, en lugar de crear un cierre repetidamente, que es un poco similar a un grupo de hilos;
La configuración es la siguiente. Para configurar razonablemente el número mínimo y máximo de conexiones de acuerdo con la situación real del proyecto, consulte el enlace para obtener el significado detallado de cada parámetro.
Además, es muy simple verificar la configuración del número de conexión. Puede escribir un programa para verificarlo usted mismo. Por ejemplo, cuando el número máximo de conexiones es 10, puede escribir un programa para verificarlo. Después de abrir 10 conexiones, la 11ª conexión estará en un estado de espera y no se puede obtener. Por lo tanto, debe configurar el número de conexiones razonablemente de acuerdo con la situación, de lo contrario puede afectar el rendimiento de la aplicación;
< value = "root"/> <Property name = "adquirireCrement" value = "1"> </propine> <Property Name = "InitialPoolSize" Value = "80"> </property> <Property name = "maxidletime" value = "60"> </Property> <Property Name = "MaxPoolSize" Value = "80"> </propiedad> <propetho name = "MinPoolSize" Value "Value" 30 "30" 30 "30" 30 "30" 30 ". name = "adquireretryDelay" value = "1000"> </propiety> <Property name = "adquireretryAttempts" value = "60"> </property> <propine name = "breakafeCquireFailure" value = "false"> </spertion> <!- Si se comparan con demasiadas conexiones, tenga en cuenta que modifique que el archivo de configuración de mySql my.ini para aumentar el número máximo de la conexión de las conexiones (vea el comando de la configuración actual (vea el comando de la configuración actual (vea el comando de modificación de mySql. ProcessList) -> </bean>
3. Comprenda el caché secundario de Hibernate y verifique
El caché de Hibernate de primer nivel se refiere al caché de toda la sesión, que está habilitado de forma predeterminada. El caché de segundo nivel es el caché de rango SessionFactory. Al configurar SessionFactory, hemos configurado el caché de segundo nivel como ehcache. A continuación, verificamos el efecto y consultamos la operación del usuario. Descubrimos que la primera consulta operará la base de datos, imprimirá la instrucción SQL y, después de actualizar la página, descubrimos que la consulta fue exitosa y no se imprimió ninguna declaración SQL. Como se muestra en la figura a continuación, podemos ver que el trabajo de caché secundario está bien;
4. Comprenda la configuración de las cosas de Spring y verifique
El llamado principio de control de transacciones es el mismo, que es garantizar la atomicidad, la consistencia, el aislamiento y la persistencia. Al programar JDBC, se controla por sí mismo. Establezca autocommit = falso para que no envíe automáticamente y luego comience a escribir operaciones específicas de la base de datos. Cuando ocurre una excepción, reversión, de lo contrario, comprometerse; De hecho, el principio de control de Spring en las cosas es similar, y se agrega con algunos empaques, configuración, etc., que es más conveniente, como controlar diferentes métodos en la capa de servicio;
La verificación es muy simple. Escriba dos operaciones de inserción en un método en el nivel de servicio (tenga en cuenta que el nombre del método debe cumplir con las reglas configuradas en el archivo de configuración de Spring), arroje una excepción en el medio y luego ejecutarlo. Si encuentra que el primer usuario se inserta con éxito, significa que el control de transacciones no es válido, de lo contrario está bien;
5. Comprenda el COI de la primavera (inyección de dependencia), entregue el objeto de acción (frijoles) de Struts2 al manejo de la primavera, frijoles personalizados, etc., y verifique
Si observa cuidadosamente, en el proceso de configuración del archivo ApplicationContext.xml, el trabajo principal es configurar información relacionada con el frijol. Estos frijoles se crean de antemano, pero de hecho los llamados frijoles son objetos;
El propósito de entregar la creación de objetos al contenedor de primavera es desacoplar;
Además, cuando se usa puntales, Spring registra la acción como Bean, que es un singleton de forma predeterminada. No cada vez que se publique una nueva acción durante el acceso, habrá riesgos cuando el acceso concurrente;
Sin embargo, puede configurar la acción en múltiples casos a través de Scope = "Prototype"; PS: La acción en STRUTS2 es múltiple de forma predeterminada;
Nota: Los frijoles configurados en ApplicationContext.xml y los frijoles configurados en anotaciones personalizadas se pueden obtener directamente durante la ejecución del programa. Esto es fácil de verificar, simplemente escriba un pequeño programa;
6. Comprenda Spring AOP (programación orientada a la sección) y escriba funciones de sección personalizadas para verificar los resultados
Esta idea se usa en muchos lugares en esta forma de programación seccional, como filtros, interceptores, control de transacciones, etc.
El principio es la reflexión de Java y el proxy dinámico, que controla el método antes y después de la ejecución, y agrega el código que desea ejecutar;
Se agrega una sección al pequeño ejemplo, y antes y después de las cadenas se imprimen antes y después de ejecutar el método. Como se muestra en la figura a continuación, funciona normalmente. Consulte la parte anterior del código:
<!-prueba de procesamiento de AOP personalizado-> <bean id = "aoptest"> </ bean> <bean id = "myaop"> </reme> <aop: config proxy-target-class = "true"> <aop: aspecto ref = "myaop"> <aop: pointcut id = "pcmethodtest" expresión = "ejecutora (* ssh.aop.aopestest.estest* (...). <AOP: ANTES PointCut-REF = "PCMethodTest" Method = "Before"/> <aop: After PointCut-Ref = "PCMethodTest" Method = "After"/> </aop: aspecto> </aop: config>
@Author un codificador de viento
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.