spring IOC AOP MVC

IOC : 控制反转，在spring中 将对象的创建和管理交给框架
DI： 依赖注入，在一个类中需要另一个类的实例时，通过spring的依赖注入，注入到当前类

通过在web.xml 中设置 加载项---> 在启动web容器时 加载springMVC.xml

一：web.xml 中的各属性配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>springMVC</display-name>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>

<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<!-- 设置加载的springMVC 配置文件 默认文件在WEB-INF下[servletName-servlet.xml] -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/springmvc.xml</param-value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>

二：在springMVC.xml 中的各属性配置：

<?xml version="1.0" encoding="UTF-8"?>

<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd" >

<!-- MVC 配置 -->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="start.do">control</prop>
<prop key="what.do">control</prop>
<prop key="login.do">control</prop>
</props>
</property>
</bean>

<bean id="control" class="test.controls.SpringControl">
<property name="commandClass">
<value>test.pojos.LogUser</value>
</property>
<property name="boLogUser" ref="boLogUser"></property> <!-- DI(set get) 配置 -->

<constructor-arg index="0" type="java.lang.String" value="yoo"/><!-- DI(constuct) 配置 -->
<constructor-arg index="1" type="test.bos.BoRegeditUser" >
<ref bean="boRegeditUser"/>
</constructor-arg>
</bean>

<!-- IOC 配置 -->
<bean id="springAop" class="test.aops.SpringAop"></bean>
<bean id="boLogUser" class="test.bos.BoLogUser"></bean>
<bean id="boRegeditUser" class="test.bos.BoRegeditUser"></bean>
<bean id="aspectClass" class="test.aops.SpringAop"></bean>

<!--AOP 配置 -->
<aop:config>
<aop:aspect ref="aspectClass">
<aop:pointcut id="pointCut" expression="execution(* test.bos.BoRegeditUser.regedit(..))" />
<aop:before method="aopMethod" pointcut-ref="pointCut"/>
<!-- <aop:after method="handle" pointcut-ref="pointCut"/> -->
</aop:aspect>
</aop:config>


</beans>

 

三：springMVC 的控制类：

package test.controls;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.registry.infomodel.User;

import org.springframework.validation.BindException;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractCommandController;
import org.springframework.web.servlet.mvc.Controller;

import test.bos.BoLogUser;
import test.bos.BoRegeditUser;
import test.pojos.LogUser;

 

public class SpringControl extends AbstractCommandController{

private BoLogUser boLogUser;
private BoRegeditUser boRegeditUser;
private String demoString;

public SpringControl(String demoString,BoRegeditUser boRegeditUser){//构造方法注入
this.boRegeditUser = boRegeditUser;
this.demoString = demoString;
}

@Override
protected ModelAndView handle(HttpServletRequest req,HttpServletResponse resp, Object command, BindException e)throws Exception {

System.out.println("control is working.......");
LogUser user = (LogUser)command;

boRegeditUser.regedit();
System.out.println("by construct DI (demoString)---->" + demoString+".......");
System.out.println("by setGet DI (boLogUser) new UserName is:：" + boLogUser.addPrefix() + user.getUsername());

System.out.println("by mvc (commandControler) --UserName is :" + user.getUsername() );
return null;
}



//set get 方法注入
public BoLogUser getBoLogUser() {
return boLogUser;
}
public void setBoLogUser(BoLogUser boLogUser) {
this.boLogUser = boLogUser;
}


}

/*public class SpringControl implements Controller{

@Override
public ModelAndView handleRequest(HttpServletRequest req,HttpServletResponse resp) throws Exception {
System.out.println("Controller is working........");
return null;
}

}*/


四：Aop方法中获得request 等对象

package test.aops;

import javax.servlet.http.HttpServletRequest;

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

 

public class SpringAop {

public void aopMethod(){
//在aop 中获得request
HttpServletRequest request =
((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();

System.out.println("aop method......... log******"+request.getParameter("username"));
}
}

======================================================================

spring aop 的execution 用法：

Spring AOP 用户可能会经常使用 execution pointcut designator。执行表达式的格式如下：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

除了返回类型模式（上面代码片断中的ret-type-pattern），名字模式和参数模式以外，所有的部分都是可选的。 返回类型模式决定了方法的返回类型必须依次匹配一个连接点。 你会使用的最频繁的返回类型模式是 *，它代表了匹配任意的返回类型。 一个全称限定的类型名将只会匹配返回给定类型的方法。名字模式匹配的是方法名。 你可以使用 * 通配符作为所有或者部分命名模式。 参数模式稍微有点复杂：() 匹配了一个不接受任何参数的方法， 而 (..)匹配了一个接受任意数量参数的方法（零或者更多）。 模式 (*) 匹配了一个接受一个任何类型的参数的方法。 模式 (*,String) 匹配了一个接受两个参数的方法，第一个可以是任意类型，第二个则必须是String类型。 请参见AspectJ编程指南的 Language Semantics 部分。

下面给出一些常见切入点表达式的例子。

  • 任意公共方法的执行：

    execution(public * *(..))

  • 任何一个以“set”开始的方法的执行：

    execution(* set*(..))

  • AccountService 接口的任意方法的执行：

    execution(* com.xyz.service.AccountService.*(..))

  • 定义在service包里的任意方法的执行：

    execution(* com.xyz.service.*.*(..))

  • 定义在service包或者子包里的任意方法的执行：

    execution(* com.xyz.service..*.*(..))

  • 在service包里的任意连接点（在Spring AOP中只是方法执行） ：

    within(com.xyz.service.*)

  • 在service包或者子包里的任意连接点（在Spring AOP中只是方法执行） ：

    within(com.xyz.service..*)

  • 实现了 AccountService 接口的代理对象的任意连接点（在Spring AOP中只是方法执行） ：

    this(com.xyz.service.AccountService)
    'this'在binding form中用的更多：- 请常见以下讨论通知的章节中关于如何使得代理对象可以在通知体内访问到的部分。

  • 实现了 AccountService 接口的目标对象的任意连接点（在Spring AOP中只是方法执行） ：

    target(com.xyz.service.AccountService)
    'target'在binding form中用的更多：- 请常见以下讨论通知的章节中关于如何使得目标对象可以在通知体内访问到的部分。

  • 任何一个只接受一个参数，且在运行时传入的参数实现了 Serializable 接口的连接点 （在Spring AOP中只是方法执行）

    args(java.io.Serializable)
    'args'在binding form中用的更多：- 请常见以下讨论通知的章节中关于如何使得方法参数可以在通知体内访问到的部分。

    请注意在例子中给出的切入点不同于 execution(* *(java.io.Serializable))： args只有在动态运行时候传入参数是可序列化的（Serializable）才匹配，而execution 在传入参数的签名声明的类型实现了Serializable 接口时候匹配。

  • 有一个 @Transactional 注解的目标对象中的任意连接点（在Spring AOP中只是方法执行）

    @target(org.springframework.transaction.annotation.Transactional)
    '@target' 也可以在binding form中使用：请常见以下讨论通知的章节中关于如何使得annotation对象可以在通知体内访问到的部分。

  • 任何一个目标对象声明的类型有一个 @Transactional 注解的连接点（在Spring AOP中只是方法执行）

    @within(org.springframework.transaction.annotation.Transactional)
    '@within'也可以在binding form中使用：- 请常见以下讨论通知的章节中关于如何使得annotation对象可以在通知体内访问到的部分。

  • 任何一个执行的方法有一个 @Transactional annotation的连接点（在Spring AOP中只是方法执行）

    @annotation(org.springframework.transaction.annotation.Transactional)
    '@annotation' 也可以在binding form中使用：- 请常见以下讨论通知的章节中关于如何使得annotation对象可以在通知体内访问到的部分。

  • 任何一个接受一个参数，并且传入的参数在运行时的类型实现了 @Classified annotation的连接点（在Spring AOP中只是方法执行）

    @args(com.xyz.security.Classified)
    '@args'也可以在binding form中使用：- 请常见以下讨论通知的章节中关于如何使得annotation对象可以在通知体内访问到的部分。



【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/leonkobe/p/3062532.html