Spring _day02_IoC注解开发入门

2022-12-05 21:32:31

1、Spring IoC注解开发入门

1.1 注解开发案例：

创建项目所需要的jar，四个基本的包(beans core context expression )，以及两个日志记录的包,还要AOP的包

① 在src下编写applicationContext.xml配置文件，进行注解开发需要引入context约束

<?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:context="h ttp://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans     http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context                 http://www.springframework.org/schema/context/spring-context.xsd"> 

      <!--组建扫描：哪些包下的类要使用IOC注解  [使用了context包]-->
     <context:component-scan base-package="com.simon.spring.*"></context:component-scan>

</beans>

② 给目标类加注解并完成注解方式的属性注入，可以没有set方法 @Value()

 * 属性如果有set方法，需要将属性注入的注解加到set方法上

 * 属性如果没有set方法，需要将注解添加到属性上

@Component(value = "userdao")
public class UserDaoImpl implements  UserDao{

    @Value("simon")
    String user_name;

    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    @Override
    public void say() {
        System.out.println("UserDao is precessing..."+user_name);
    }
}

③ service测试：

    @Test
    public void test1(){
       ApplicationContext applicationContext = new                                      ClassPathXmlApplicationContext("config/applicationContext.xml");
        UserDao userdao = (UserDao) applicationContext.getBean("userdao");
        userdao.say();
    }

1.2 Spring的IoC注解详解：

1.2.1@Component：组件

修饰一个类，表示将这个类交给Spring管理
这个类有三个衍生注解：修饰类
@Service : web层
@controller ： service层
@Repository ：dao层

1.2.2属性注入的注解

普通属性：使用@Value()注解
引用属性：使用@Autowired()，是按照类型进行注入的；
@Autuwired()+@Qulifier()会按照名称进行注入
spring实现的一套规范接口里提供了一个替代注解：@Resource() --按照名称进行注入
- 提供一个User类，将User的一个对象注入到UserDaoImpl 的属性里面去
  
  @Component("user111")
  public class User {
```
@Value("Simon")
String name;
@Value("男")
String sex;
@Value("19")
Integer age;

@Override
public String toString() {
    return "User{" +
            "name='" + name + '\'' +
            ", sex='" + sex + '\'' +
            ", age=" + age +
            '}';
}
```
  }

UserDaoImpl:

@Component(value = "userdao")
public class UserDaoImpl implements  UserDao{

    @Value("Daniel")
    String user_name;

   // @Autowired
   // @Qualifier("user111")

    @Resource("user111")
    User user;

    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    @Override
    public void say() {
        System.out.println("UserDao is precessing..."+user_name+"...."+user);
    }
}

1.3、Bean的其他注解

1.3.1初始化方法以及在工厂被关闭时执行的方法 : 【生命周期的注解配置】

    @PostConstruct  //相当于<bean id=" class=" init-method="init">
    public void  init(){
        System.out.println("Userdao 被初始化了。。。");
    }

    public void save(){
        System.out.println("Userdao 正在执行save()方法。。。");
    }

    @PreDestroy   //相当于<bean id=" class=" init-method="destory">
    public void destory(){  //工厂关闭时才会执行
        System.out.println("Userdao 被销毁了。。。");
    }

1.3.2Bean的作用范围的注解：

@Scope : 【加在类上】

singleton ：默认的，Spring 会采用单例模式创建这个对象。

prototype ：多例模式。（Struts2和Spring整合一定会用到）

request ：应用在web项目中，Spring创建这个类以后，将这个类存入到request范围中。

session ：应用在web项目中，Spring创建这个类以后，将这个类存入到session范围中。

globalsession ：应用在web项目中，必须在porlet环境下使用。但是如果没有这种环境，相对于session。

1.4 IoC的XML和注解的开发比较：

适用场景：
- XML：可以适用任何场景 ==》结构清晰，后期维护方便
- 注解：有些地方用不了，这类不是自己提供的 ==》开发方便

1.5 XML和注解整合开发：

使用XML管理Bean，使用注解完成属性注入

使用前先打开注解方式配置：【包扫描时配置在类上的】

    <context:annotation-config></context:annotation-config>   <!--允许使用注解的方式注入-->
    <bean id="productService" class="com.simon.spring.demo.ProductService"></bean>
    <bean id="orderDao" class="com.simon.spring.demo.OrderDao"></bean>

测试：在ProductService中注入OrderDao

public class ProductService {
    @Autowired
    private OrderDao dao;

    public  void save(){
        dao.save();
        System.out.println("ProductService....");
    }
}

2、Spring Aop的开发(AspectJ的XML的方式)

AOP思想最早由AOP联盟提出，Spring是使用这种思想最好的框架。

Spring的AOP有自己的实现方式(非常繁琐)。AspectJ是一个AOP框架，Spring引入AspectJ作为自身的 AOP开发

AOP采取横向抽取机制，取代了传统的纵向集成机制横向抽取采用动态代理实现

Spring AOP底层原理就是动态代理：

JDK 动态代理：只能对实现了接口的类产生代理
CGLIB动态代理（类似javassist的第三方技术）：对没有实现接口的类产生代理对象，==》生成子类对象

2.1 JDK动态代理示例

2.2 CGLIB动态代理示例

2.3 AOP的相关技术名词：

Joinpoint：连接点，可以被拦截增强的点都可以被称作连接点
Pointcut：切入点，真正被拦截增强的点
Advice：通知/增强，比如要对save()进行权限校验，权限校验的方法就是通知，是方法层面的增强
Introduction：引介。类层面的增强，在类中动态的增加一个方法
Target：目标，就是被增强的对象（类：例如UserDao）
Weaving：织入，代表一个过程,将通知(Advice)应用到目标(Target)上的过程叫做织入
Proxy：代理对象，被增强后产生的对象
Aspect：切面，多个通知和多个切入点的组合叫做切面

2.4开发案例：

引入jar包：六个基本的jar包之外，还需要四个：依赖库中AOP联盟包、aspectj的包，Spring中Aop的包，spring和Aspect整合的包

引入约束：

  <!--将切面类交给Spring管理-->
  <bean id="myaspect" class="com.simon.spring.demo2.MyAspectXML"></bean>

  <!--通过AOP的配置完成对目标类的增强-->
  <aop:config>
      <!--表达式配置哪些类的哪些方法需要进行增强-->
      <aop:pointcut  id="pointcut1" expression="execution(*  com.simon.spring.demo2.UserDaoImpl.save(..))" ></aop:pointcut>

      <!--配置切入点-->
      <aop:aspect ref="myaspect">
          <aop:before method="check" pointcut-ref="pointcut1"></aop:before>
      </aop:aspect>
  </aop:config>

引入Spring包中的test包可进行spring和junit的整合开发
Advice:

public class MyAspectXML {
public void check(){
System.out.println("权限校验~~~");
}
}

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:config/aspect.xml")
public class SpringDemo1 {

    @Autowired
    private UserDao dao;

    @Test
    public void test1(){
        dao.save();
    }
}

2.5 通知的类型

前置通知：在目标方法执行之前进行操作

后置通知：在目标方法执行之后进行操作，可以获得方法的返回值

环绕通知：在目标方法执行前后进行操作

异常抛出通知：程序出现异常时候进行的操作

最终通知：无论代码出不出错，最终都会执行的方法

示例：

 <!--1.配置目标对象：被增强的对象-->
    <bean id="userdaoImpl" class="com.simon.spring.demo2.UserDaoImpl"></bean>

    <!--将切面类交给Spring管理-->
    <bean id="myaspect" class="com.simon.spring.demo2.MyAspectXML"></bean>

    <!--通过AOP的配置完成对目标类的增强-->
    <aop:config>
        <!--表达式配置哪些类的哪些方法需要进行增强-->
        <aop:pointcut  id="pointcut1" expression="execution(* com.simon.spring.demo2.UserDaoImpl.save(..))" ></aop:pointcut>
        <aop:pointcut  id="pointcut2" expression="execution(* com.simon.spring.demo2.UserDaoImpl.delete(..))" ></aop:pointcut>
        <aop:pointcut  id="pointcut3" expression="execution(* com.simon.spring.demo2.UserDaoImpl.update(..))" ></aop:pointcut>
        <aop:pointcut  id="pointcut4" expression="execution(* com.simon.spring.demo2.UserDaoImpl.find(..))" ></aop:pointcut>

        <!--配置切入点-->
        <aop:aspect ref="myaspect">
            <!--前置通知：-->
            <aop:before method="check" pointcut-ref="pointcut1"></aop:before>
            <!--后置通知：-->
            <aop:after-returning method="log" pointcut-ref="pointcut2" returning="result"></aop:after-returning>
            <!--环绕通知-->
            <aop:around method="around" pointcut-ref="pointcut3"></aop:around>
            <!--异常抛出通知-->
            <aop:after-throwing method="afterthrowing" pointcut-ref="pointcut4" throwing="ex"></aop:after-throwing>
            <!--最终通知-->
            <aop:after method="after" pointcut-ref="pointcut4"></aop:after>
        </aop:aspect>
    </aop:config>

各个通知：

public class MyAspectXML {

    //前置通知
    public void check(){
        System.out.println("前置通知~~~");
    }

    //后置通知 ===》切入点可能有返回值，记成Object类型
    public void log(Object result){
        System.out.println("后置通知。。。"+result);
    }

    //环绕通知 ===》传入连接点
    public Object around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("环绕前通知。。。");
        Object proceed = point.proceed();
        System.out.println("环绕后通知。。。");
        return proceed;
    }

    //异常抛出通知 ===接收异常信息，参数名和XML配置的一致
    public void afterthrowing(Throwable ex){
        System.out.println("异常通知" + ex);
    }

    //最终通知
    public void after(){
        System.out.println("最终通知。。。。");
    }
}

测试案例：

    @Test
    public void test1(){
        dao.save();
        dao.delete();
        dao.update();
        dao.find();
    }

2.5.Spring的切入点表达式写法

基于excution的函数完成的
- 语法：了解。。。

码农公寓

相关文章