Struts2.3.24 + Spring4.1.6 + Hibernate4.3.11 + MySQL5.5.25 Construção do ambiente de desenvolvimento e instruções relacionadas.
1. Objetivo
1. Construa um ambiente de desenvolvimento tradicional de SSH e execute -o com sucesso (insira, consulta)
2. Entenda a configuração do pool de conexão C3P0
3. Entenda o cache secundário do hibernato e verifique
4. Entenda a configuração das coisas da primavera e verifique
5. Entenda o COI da Spring (injeção de dependência), entregue o objeto de ação (Bean) de Struts2 ao gerenciamento da primavera, feijão personalizado, etc., e verifique se
6. Entenda a Spring AOP (programação orientada à seção) e escreva funções de seção personalizada para verificar os resultados
2. Preparação
Ambiente de Desenvolvimento: Eclipse para Java EE; mysql5.5.25; jdk1.7.0_79; Navicat10.1.7 (opcional);
Crie uma demonstração de banco de dados:
/*Navicat MySQL Data Transfersource Server: locicalHost_3306Source Versão: 50519Source Host: Localhost: 3306 Banco de dados: DemoTarget Type: MySQLTarget Server: 50519File Encoding: 65001Date: 2016-01-01-09 23: -------------------------------- Tabela de tabela para `user`-- -------------------------------------- Tabela se existe` user`; crie tabela `user` (` id` bigint (20) não nulo Auto_increment, `conta 'varchar (200) não null,` name' varchar (200) não null, `` endereço ' Charset padrão = utf8;
Crie um novo projeto da web, a estrutura do diretório é a seguinte:
Prepare o pacote JAR e coloque-o no diretório LIB da Web-Inf (se você estiver interessado, pode usar o MAVEN para gerenciar o processo, mas às vezes é muito lento para baixar o pacote JAR ...)
Os pacotes de jar relacionados podem ser encontrados nos suportes baixados, primavera e hibernação. Aqui está uma referência. Alguns deles podem ser excluídos, como os pacotes JAR na parte do MVC da primavera:
3. Configure web.xml
Configure um filtro STRUTS2 para mapear todas as solicitações *.Action e são tratadas pelo objeto StrutSprepareAndExecuteFilter;
Configure o parâmetro de contexto-param e especifique o caminho do arquivo de configuração da mola. Os parâmetros em <contexto-param> podem ser obtidos usando o servletContext.getInitParameter ("param-name");
Configurar o ouvinte é principalmente para ler as informações do arquivo de configuração ApplicationContext.xml, criar feijões e outros trabalhos de inicialização;
<?xml version="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/xmls/javaee/web-web-web-web-web--/java.sun.com/xmls/javaeeeee/web-web-web-web-web-web-web-web-web-web-web-web-web-web-web-/java.sun.com/ <lame-name> ssh </lisplay-name> <filter> <filter-name> struts2 </filter-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.strutsprepareAndExecuteFilter </filter-class> </filterame> <filter-mapping> <name> struts2 </filter-class> </filtelame> <filter-mapping> <-name> <rictattern>*. Ação </url-tattern> </ftrhter-Mapping> <xectjest-param> <amam-name> contextCenfigLocation </param-name> <amam-value> classPath: ApplicationContext.xml </param-value> </ventcent-param> <Ilvé> <listener-class> org.springframework.web.context.contextLoaderListener </lister-class> </lister> <lorde-file-list> <lmed -file> index.jsp </ld-Welcome-file> </lding -file-list> </bile-App>
4. Configure o ApplicationContext.xml
Configure a digitalização automática de @repostory, @service e outras anotações no pacote ssh e gerar feijões correspondentes;
Configurar a fonte de dados (o conjunto de conexões JDBC é C3P0, você pode consultar a configuração detalhada do C3P0). A principal função do pool de conexões é fornecer rapidamente a conexão e reutilizá -la. Não requer cada destruição e criação. Requer configuração de nome de usuário, senha, número máximo de conexões, número mínimo de conexões, número inicial de conexões e outros parâmetros relacionados;
Configurar sessionFactory (você pode consultar a configuração detalhada do hibernato, onde você configura para ativar o cache do nível 2), a função principal é fornecer sessão e executar instruções SQL; Aqui usaremos o Hibernatetemplate para operar o banco de dados para facilitar o controle físico da mola; PS, o mapeamento entre as classes e as tabelas de banco de dados também deve ser configurado na configuração do hibernato;
Configure o gerente de transação Bean como HibernateTransactionManager e inicialize o membro do atributo SessionFactory ao Bean SessionFactory configurado anteriormente;
Configure as características de propagação da transação e configure uma seção para se referir a ela e conduza o controle de transações de todos os métodos e subpackagens de adição, excluir, atualizar e salvar em todos os pacotes e subpackagens do SSH.Service. Você também pode configurar o comportamento de propagação da transação e outros parâmetros;
Finalmente, existe uma configuração personalizada relacionada à AOP, que aplica a seção personalizada 'MyAop' para controlar todos os métodos que começam com testes sob ssh.aop.aoptest, e os resultados serão verificados posteriormente;
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: p = "http://www.springframework.org/schema 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://www.springframework.org/schema/beans http://www.springframework.org/schema/beans http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/sring-apa.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tg/schema 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 "> <!-digitaliza o caminho de classe em busca de componentes anotados (@RePostory e @Service que serão auto-agregados como spring)-<contexto: component-scan e @Serice que será auto-agregado como spring)- Nome = "DataSource" Destroy-Method = "Close"> <Propriedade name = "driverclass" value = "com.mysql.jdbc.driver" /> <propriedade name = "jdbcurl" value = "jdbc: mysql: // lochost: 3306 /demónos" /> <name = "" user "" name = "adquiririncrement" value = "1"> </propriedade> <propriedade name = "InitialPoolSize" value = "80"> </propriedade> <propriedade name = "maxidleTime" value = "60"> </propriedade> <namesize = "maxpoolsize" value = "80"> </propriedade> <weead> <names </minpoolsize "" 4xPoolSize "=" 80 "> </propriedade> <name =" minpoolsize "" value = "1000"> </propriedade> <propriedade name = "adquireretryAttempts" value = "60"> </property> <propriedades name = "breakafteracquirefailure" value = "false"> </propriedade> <!-Se comandos se comandos. <bean id = "sessionfactory"> <propriedade name = "DataSource" ref = "DataSource"/> <propriedade name = "hibernateProperties"> <prop key = "hibernate.dialect"> org.hibernate.dialect.mysqldialect </prop> <pke = "hibernate.Show_SHOW_SELT.SQLECT.MYSQLDIALECT </prop> key = "hibernate.hbm2ddl.auto"> update </prop> <props key = "current_session_context_class"> thread </prop> <propr key = "hibernate.cache.use_second_level_cache"> </prop. key = "hibernate.cache.region.factory_class"> org.hibernate.cache.ehcache.ehcacheregionFactory </pp> <propi key = "hibernate.cache.use_Query_cache"> true </pup> <prop key = "hibernate.cache.provider_configuration_file_resource_path"> ehcache.xml </prop> </pup> </sports> </property> <propriedades name = "Mappinglocations" <list> <Value> Classpath: ssh/model.hb <! name = "annotatedclasses"> <list> <Value> ssh.model.user </value> </list> </propriedade>-> </bean> <!-Configurando gerenciador de transações-> <bean id = "transactionManager"> <nome da propriedade = "session" ref = "de session"/> </! <tx: atributos> <tx: método name = "add*" propagation = "requerir" leitura somente = "false" rollback para = "java.lang.exception"/> <tx: name do método = "delete*" propagation = "requerido" requisito ") rollback-for = "java.lang.exception"/> <tx: método name = "save*" propagation = "requerir" leitura somente = "false" rollback-for = "java.lang.exception"/> </tx: atributes> </tx: conselhos> <aop: config> <aop: pop untd ida "method "PC" SSH.SERVICE ..*.*(..)) "/> <AOP: Advisor Pointcut-ref =" pcMethod "conselhos-ref =" txadvice "/> </AOP: config> <!-Teste de processamento AOP personalizado-> <Bean id =" AOPTEST "> </Bean> <Bean Id =" Myap "Myap" Myap "Myap" Myap "Myap" MyAp " Proxy-alget-class = "true"> <AOP: aspecto ref = "myaop"> <aop: Pointcut id = "pcMethodtest" Expression = "Execution (* ssh.aop.aoptest.test* (..))"/> <AoP: antes de Point-ref = "pcmethodtest") Pointcut-ref = "pcMethodTest" Method = "After"/> </AOP: Aspect> </aOP: config> </ Beans>
5. Configure as suportes.xml
Configure as estruturas.
Configure o tipo de resultado para "JSON" e você também pode configurar outras coisas. Aqui, para a conveniência da interação de dados front-end e back-end, ela é configurada no formato JSON;
Configurar duas ações, Adduser e Queryalluser;
<? xml versão = "1.0" Encoding = "utf-8"?> <! Doctype suporta public "-// Apache Software Foundation // DTD Struts Configuration 2.3 // pt" "httpacty//struts.apache.org/dds/stuts-2.3.djat"> <Struts.Apache.org/dts/Struts-2.3 <Constant name = "struts.enable.dynamicmethodinvocation" value = "false" /> <nome constante = "struts.devmode" value = "false" /> <names package = "padrão" estends = "struts-default, JSON-DEFAULT"> <-RESULTS> <resultado = "json">> <sson> <sson> <avers-kafault, JSON-DEFAULT "> <-RESULTS> name="contentType">text/html</param> </result> </global-results> <action name="addUser" method="addUser"> <result>.</result> </action> <action name="queryAllUser" method="queryAllUser"> <result>.</result> </action> </package> <!-- Add packages here --></struts>
6. Escreva código relevante
Notas:
O DAO herda a classe HibernatedAosupport e todas as operações relacionadas ao banco de dados são operadas pelo HibernateTemplate;
Adicione anotações correspondentes à camada DAO, camada de serviço e ação e registre -se como grãos de mola;
O código anexado é o seguinte:
UserAction.java
pacote ssh.action; importar java.io.printwriter; importar java.util.list; importar javax.annotation.resource; importar javax.servlet.http.httpServletReQuest; import javax.sertlet.http.httletLeStger; importe; importe; importe; importe; importe; importe; importe; importen.mertTeL.HTTP.HTTPLEFESTER; org.apache.struts2.servletActionContext; importar org.springframework.stereotype.controller; importar ssh.aop.aoptest; importar ssh.model.user; import ssh.service.userService; import.google.gson.gson; @Controllerpublic Logsusterice; Logger.getLogger (userAction.class); @Resource privado UserService UserService; @Resource Private AOPTEST AOPTEST; public void addUser () {printWriter out = null; tente {httpServletRequest request = servletActionContext.getRequest (); HttpServletResponse Response = servletActionContext.getResponse (); Response.setContentType ("Texto/html; charset = utf-8"); String conta = request.getParameter ("conta"); Nome da string = request.getParameter ("nome"); String endereço = request.getParameter ("endereço"); Usuário do usuário = novo usuário (); user.setAccount (conta); user.setAddress (endereço); user.setName (nome); userService.add (usuário); out = Response.getWriter (); out.Write (New Gson (). Tojson ("Sucesso")); } catch (Exceção e) {e.printStackTrace (); logger.error (e.getMessage ()); if (out! = null) out.write (new gson (). Tojson ("Fail")); } finalmente {out.flush (); out.Close (); }} public void queryallUser () {printWriter out = null; AOPTEST.TEST1 (); AOPTEST.TEST2 (); //logger.error("i "); tente {httpServletResponse Response = servletActionContext.getResponse (); Response.setContentType ("Texto/html; charset = utf-8"); Gson gson = new gson (); LIST <usery> userlist = userservice.QueryallUser (); String gSonstr = gson.tojson (UserList); out = Response.getWriter (); out.write (GSonstr); } catch (Exceção e) {e.printStackTrace (); logger.error (e.getMessage ()); if (out! = null) out.write (new gson (). Tojson ("Fail")); } finalmente {out.flush (); out.Close (); }}}AOPTEST.java
pacote ssh.aop; public class Aoptest {public void test1 () {System.out.println ("o método AOPTEST TEST1 está em execução ~"); } public void test2 () {System.out.println ("o método AOPTEST TEST2 está em execução ~"); }}Myaop.java
pacote ssh.aop; public class myaop {public void antes () {system.out.println ("befor ~"); } public void depois () {System.out.println ("After ~"); }}Basedao.java
pacote ssh.dao.base; importar javax.annotation.resource; importar org.hibernate.sessionFactory; importar org.springframework.orm.hibernate4.support.hibernateDaosUpport; public classe baseada em hiBerningAssuport (@Resource SettyStyStyStys Public; this.SetSessionFactory (SessionFactory); }}
Userdao.java
pacote ssh.dao; importar java.util.ArrayList; importar java.util.list; importar org.springframework.orm.hibernate4.hibernatetemplate; importar org.springframework.tereotype.repositione; importem.bringFramework.bringReotype.reposition; estende baseado em base {public void add (usuário do usuário) {this.gethibernatetemplate (). salvar (usuário); } @Suppresswarnings ("desmarcado") Lista pública <suser> queryallUser () {list <suser> usuários = new ArrayList <suser> (); HibernateTemplate hibernateTemplate = this.gethibernateTEMplate (); hibernateTemplate.setCachekeries (true); usuários = (list <suser>) hibernateTemplate.find ("do usuário"); hibernateTemplate.setCachekeries (false); devolver usuários; }}User.java
pacote ssh.model; importar java.io.Serializable; classe pública implementa o usuário serializável { / ** * * / private estático final serialversionUIDuid = -6190571611246371934l; Private Long Id; conta de string privada; nome de string privado; endereço de string privado; public String getAccount () {Return Account; } public string getName () {return name; } public string getAddress () {retornar endereço; } public void setAccount (String Account) {this.account = conta; } public void setName (nome da string) {this.name = name; } public void setAddress (endereço da string) {this.address = endereço; } / ** * @RETURN O ID * / Public Long GetId () {return ID; } / ** * @param id o id para definir * / public void setId (longo id) {this.id = id; }}User.hbm.xml
<? xml versão = "1.0"?> <!-~ Hibernate, persistência relacional para Java idiomático ~ ~ Copyright (c) 2010, Red Hat Inc. ou contribuintes de terceiros, conforme indicado pelas tags @Author ou do atributo de direitos autorais expressos ~ declarações aplicadas pelos autores. Todas as contribuições de terceiros são distribuídas sob licença pela Red Hat Inc. ~ ~ Este material protegido por direitos autorais é disponibilizado a qualquer pessoa que deseje usar, modificar, copiar ou redistribuí-lo sujeito aos termos e condições da licença pública em geral, publicada pela Free Software Foundation. ~ ~ Este programa é distribuído na esperança de que seja útil, ~ mas sem qualquer garantia; Sem a garantia implícita de comercialização ~ ou aptidão para uma finalidade específica. Veja a Licença Pública Geral menor GNU para obter mais detalhes. ~ ~ Você deveria ter recebido uma cópia da Licença Pública Geral GNU menor ~ junto com esta distribuição; Caso contrário, escreva para: ~ Free Software Foundation, Inc. ~ 51 Franklin Street, Quinto andar ~ Boston, MA 02110-1301 EUA-> <! "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><BERNATE-MAPPING package =" ssh.model "> <classe name =" user "tabela =" user "> <cache usege =" read-write "/> <idie" idi "iD" "" ">"> <cache usage = "read-write"/> <g name = "id" column = "idi"> "idiation> <cache =" read-write "/> <g name =" id "column =" idi ">" idiation> <cache = "read-write"/> <g name = "id" column = "idi"> "idiation> <cache =" read-write "/> <id name =" id "" "" " type = "java.lang.string" column = "conta"/> <propriedade name = "name" type = "java.lang.string" column = "name"/> <propriedade name = "endereço" type = "java.lang.string" column = "endereço"/> </class> </hibernate-mapping>
UserService.java
pacote ssh.service; importar java.util.list; importar javax.annotation.resource; importar org.springframework.tereotype.service; importar ssh.dao.userdao; import ssh.model.userr; usericepublic class Uservice {@Resource list public <suser> queryallUser () {return userdao.queryallUser (); } public void add (usuário do usuário) {userdao.add (usuário); }}index.jsp (lembre -se de adicionar a biblioteca jQuery)
<%@ página de página = "java" contentType = "text/html; charset = utf-8" pageEncoding = "utf-8"%> <! Doctype html public "-// w3c // dtd html 4.01 transitório // en" "http://www.w3.org/tr/html4/loose.dtd"><html> <head><meta http-equiv =" content-type "content =" text/html; charset = utf-8 "> <title> insert aqui </title> <estilo> <estilo. 20px;}</style></head><body><div style="text-align: center;"> <div><label>Account: </label><input id="account" type="text"/></div> <div><label>Name: </label><input id="name" type="text"/></div> <div><label>Address: </label><input id="address" type = "text"/> </div> <div> <button id = "adduser"> add </botão> </div> <h3> Lista de usuários: </h3> <ul id = "userlist"> </ul> <script type = "text/javascript" src = "js/jQuery-1.11.1.minjs"> $ .ajax ({url: 'QueryallUser.action', type: 'post', datatype: 'json', sucesso: function (data) {try {for (var i = 0; i <data.length; i ++) {$ ("#userList"). style = 'cor: vermelho'> id = "+dados [i] .id+" </span>, conta = "+dados [i] .Account+", name = "+dados [i] .name+", endereço = "+dados [i] .Address+" </li> "); }} catch (e) {}; }, erro: function (e) {alert ("erro sys"); }}); $ ("#addUser"). on ("clique", function () {var de conta = $ ("#conta"). val (); var name = $ ("#name"). Sucesso: Data) {Try {$ ("#UserList"). Append ("<li> Account =" }); }); </script> </body> </html>7. Resultados da verificação
Volte ao início, comece a se familiarizar com as tecnologias relevantes e verifique os resultados
1. Construa um ambiente de desenvolvimento tradicional de SSH e execute -o com sucesso (insira, consulta)
A figura a seguir: consultar e adicionar usuários com sucesso;
2. Entenda a configuração do pool de conexão C3P0
As conexões do banco de dados são recursos caros, e a abertura e o fechamento consome desempenho. Portanto, eles podem ser gerenciados com um pool de conexão, inicializando várias conexões e reutilizando -as, em vez de criar um fechamento repetidamente, o que é um pouco semelhante a um pool de threads;
A configuração é a seguinte. Para configurar razoavelmente o número mínimo e máximo de conexões de acordo com a situação real do projeto, consulte o link para obter o significado detalhado de cada parâmetro.
Além disso, é muito simples verificar a configuração do número de conexão. Você pode escrever um programa para verificar sozinho. Por exemplo, quando o número máximo de conexões é 10, você pode escrever um programa para verificá -lo. Após a abertura de 10 conexões, a 11ª conexão estará em um estado de espera e não poderá ser obtida. Portanto, você deve configurar o número de conexões razoavelmente de acordo com a situação, caso contrário, ela poderá afetar o desempenho do aplicativo;
<!-Suporte Fonte de dados-> <name bean = "DataSource" Destroy-method = "Close"> <propriedade name = "driverclass" value = "com.mysql.jdbc.driver" /> <nome da propriedade "JDBCurl" Value = "JDBC: MySQL: // LocalHost: 3306 /Demo" value = "root"/> <propriedade name = "adquiririncrement" value = "1"> </property> <propriedade name = "InitialPoolSize" value = "80"> </propriedade> <propriedade name = "maxidleTime" value = "60"> </propriedade> <nome da propriedade = "maxpoolsize" = "80"> <//</</"</propriedades> </propriedade> <nome da propriedade =" maxpoolsize "=" 80 "> <//</</" </"> </propriedade> <nome da propriedade =" maxpoolsize "=" 80 "> <//</</" </ name = "adquireretryDelay" value = "1000"> </propriedade> <propriedade name = "adquirreretryattempts" value = "60"> </propriedade> <propriedades name = "breakafterAcQuireFailure" value = "false"> </propriedade> <!- Se muitas conexões aparecem, observe que o máximo de configuração do arquivo de configuração do my.iniini do my.iniini do my.ininiini do my.ininiini do my.ininiini do my.iniNiNiNiNiNiNiNiNiNiNiNiNiNiNiNiNiNiNi. Mostrar Lista de Processos) -> </rience>
3. Entenda o cache secundário do hibernato e verifique
O cache de hibernato de primeiro nível refere-se ao cache em toda a sessão, que é ativado por padrão. O cache de segundo nível é o cache do intervalo de sessões. Ao configurar o SessionFactory, configuramos o cache de segundo nível como ehcache. Em seguida, verificamos o efeito e consultamos a operação do usuário. Descobrimos que a primeira consulta operará o banco de dados, imprimirá a instrução SQL e, após a atualização da página, descobrimos que a consulta foi bem -sucedida e nenhuma instrução SQL foi impressa. Como mostrado na figura abaixo, podemos ver que o trabalho secundário do cache está ok;
4. Entenda a configuração das coisas da primavera e verifique
O chamado princípio do controle de transações é o mesmo, que é garantir atomicidade, consistência, isolamento e persistência. Ao programar o JDBC, ele é controlado por si só. Defina o AutoCommit = False para não enviar automaticamente e, em seguida, comece a escrever operações específicas de banco de dados. Quando ocorre uma exceção, a reversão, de outra forma, se comprometa; De fato, o princípio de controle da primavera sobre as coisas é semelhante e é adicionado com algumas embalagens, configuração etc., o que é mais conveniente, como o controle de diferentes métodos na camada de serviço;
A verificação é muito simples. Escreva duas operações de inserção em um método no nível de serviço (observe que o nome do método deve estar em conformidade com as regras configuradas no arquivo de configuração da primavera), faça uma exceção no meio e executá -lo. Se você achar que o primeiro usuário é inserido com sucesso, significa que o controle da transação é inválido, caso contrário, está ok;
5. Entenda o COI da Spring (injeção de dependência), entregue o objeto de ação (Bean) de Struts2 ao gerenciamento da primavera, feijão personalizado, etc., e verifique se
Se você observar com cuidado, no processo de configuração do arquivo ApplicationContext.xml, o trabalho principal é configurar informações relacionadas ao feijão. Esses feijões são criados com antecedência, mas de fato os chamados feijões são objetos;
O objetivo de entregar a criação de objetos para o recipiente de mola é se dissipar;
Além disso, ao usar struts, a primavera registra a ação como feijão, que é um singleton por padrão. Sempre que uma nova ação é emitida durante o acesso, haverá riscos quando o acesso simultâneo;
No entanto, você pode configurar a ação em vários casos através do scope = "protótipo"; PS: A ação no STRUTS2 é multi-case por padrão;
Nota: Os feijões configurados no ApplicationContext.xml e os feijões configurados em anotações personalizados podem ser obtidos diretamente durante a execução do programa. É fácil verificar, basta escrever um pequeno programa;
6. Entenda a Spring AOP (programação orientada à seção) e escreva funções de seção personalizada para verificar os resultados
Essa idéia é usada em muitos lugares nessa forma de programação secional, como filtros, interceptores, controle de transações, etc.
O princípio é a reflexão Java e o proxy dinâmico, que controla o método antes e depois da execução, e adiciona o código que você deseja executar;
Uma seção é adicionada ao pequeno exemplo e, antes e depois, as strings são impressas antes e depois que o método for executado. Como mostrado na figura abaixo, funciona normalmente. Consulte a parte anterior do código:
<!-Teste de processamento de AOP personalizado-> <bean id = "AOPTEST"> </bean> <bean id = "myaop"> </ean> <aop: config proxy-alget-class = "true"> <aOp: aspecto ref = "myaop"> <aP: poptcut id = "pcmethodtestest" = "Expression"> <aP: POP: " SSH.AOP.AOPTEST.TEST*(..)) "/> <AOP: Antes de Pointcut-ref =" pcMethodtest "Method =" Antes "/> <AOP: After Pointcut-ref =" PcMethodTest "Method =" After "/> </aOP: Aspect> </aop: config>
@Author um codificador semelhante ao vento
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.