Spring1

1.引入依赖

<dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.2.10.RELEASEversion>
        dependency>
1
2
3
4
5

2.spring的配置文件

命名为applicationContext.xml

文件内容和解释

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

    <bean id="bookdao" class="dao.BookDaoImpl">bean>
    
    
    <bean id="bookservice" class="service.BookServiceImpl">
        
        <property name="bookDao" ref="bookdao">property>

    bean>
    

    <bean id="factory" class="factory.Factory" factory-method="getBookService">bean>

    
    <bean id="class1" class="factory.ClassS">bean>
    
    <bean id="classs" factory-method="getService" factory-bean="class1">bean>

    
    <bean id="bookdaofactory" class="factory.bookFactory">bean>

    

    

    

    


beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

bean属性的解释
id是这个bean的名字，提供给外部使用的，
name属性是用来给bean定义别名的，他的别名可以有一个也可以有多个（用,;空格分割），而且他的别名在其他set属性注入时也可以使用
class是实现类，他是不可以是接口的
scope,单例（singleton)还是多例
为什么是单例的？======= 管理可以复用的对象
适合交给容器进行管理的bean: 表现层对象，业务层对象，数据层对象，工具等
不适合交给容器管理的bean： 封装实体的域对象
init-method 生命周期初始化方法
destory-method 生命周期销毁方法 （一般写了也不会执行，他是在容器关闭时执行的，除非执行close和其他一种关闭时，才会执行，下面有详细解释）
autowire 自动装配，不经常使用，后面使用注解进行自动装配
factory-method 应用于静态工厂或实例工厂
factory-bean 实例工厂bean
lazy-init 控制bean延迟加载

实例化bean的三种方式：

1.使用构造方法实例化bean

public class BookServiceImpl implements BookService{

    @Override
    public void getStr() {
        System.out.println("service....hahahha");
    }
}
1
2
3
4
5
6
7

applicationContext.xml

<bean id="bookservice" class="service.BookServiceImpl"/>
1

构造方法实例化bean，需要注意spring默认是用无参构造方法进行实例化的，如果说你提供了一个有参构造，且没有提供无参构造，那么控制台汇报：BeanCreationException
而且，你在spring中写构造方法时会发现，不管是写私有的构造方法还是，公共的构造方法他都可以创建bean。因为spring里面用到了反射
2.静态工厂实例化bean

public class Factory {

public static BookService getBookService(){
    /**
     * 工厂里面不是只有实例化方法，可能还有其他配置。工厂不可忽视
     */
    return new BookServiceImpl();
}
}
1
2
3
4
5
6
7
8
9

applicationContext.xml

  

    <bean id="factory" class="factory.Factory" factory-method="getBookService">bean>

1
2
3
4
5
6

3.实例工厂实例化bean
有两种实现方式
第一种方法

public class ClassS {
    public BookService getService(){
        return new BookServiceImpl();
    }
}
1
2
3
4
5

applicationContext.xml

    
    <bean id="class1" class="factory.ClassS">bean>
    
    <bean id="classs" factory-method="getService" factory-bean="class1">bean>
1
2
3
4
5
6
7
8

第二种：

public class bookFactory implements FactoryBean<BookDao> {
    //代替原始实例工厂创建对象的方法
    @Override
    public BookDao getObject() throws Exception {
        return new BookDaoImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return BookDao.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
        //true就是单例，false就是非单例的。
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

applicationContext.xml

  
    <bean id="bookdaofactory" class="factory.bookFactory">bean>
1
2

bean的生命周期

bean的生命周期
初始化容器：
1.创建对象（new在座的事情）
2.执行构造方法
3.执行属性注入（set操作)
4.执行bean初始化方法
使用bean
执行业务操作
关闭/销毁容器
执行bean销毁方法
init-method,初始化操作
destory-method,
容器关闭前才会执行销毁操作
1.（暴力）要想看到此方法执行需要在main方法中关闭容器close
2.关闭钩子ctx.registerShutdownHook()

依赖注入

1.setter注入引用类型 ref

2.setter注入简单类型 value

3.构造器注入引用类型
前面的构造器：跟一般的构造器一样的



4.构造器注入基本数据类型

``

      setter注入灵活性较强，会导致null对象出现
      自己开发的模块推荐使用setter注入
1
2

自动装配

依赖自动装配有四种(按类型，按名称，构造器，不使用自动装配)，只写两种
用于引用类型依赖注入，不能对简单类型进行操作，
自动装入的优先级低于setter注入与构造器注入，同时出现，自动装配自动失效
方式：按类型：(常用——可以不起名字id)

按名称：(会使得xmL文件和前面的java文件的名称大力耦合，不推荐)

集合注入

setter方式
java

public class ClassS {
    private List<String> list ;
    private int[] array;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public BookService getService(){
        return new BookServiceImpl();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

applicationContext.xml

      <bean id=" " class="" >
        <property name="array">
            <array>
                <value>100value>
                <value>200value>
            array>
        property>
        <property name="list">
            <list>
                <value>ssssvalue>
                <value>aaaavalue>
            list>
        property>
        <property name="set">
            <set>
                <value>ssssvalue>
                <value>aaaavalue>
            set>
        property>
        <property name="map">
            <map>
                <entry key="sex" value="男">entry>
            map>
        property>
        <property name="properties">
            <props>
                <prop key="sex">男prop>
            props>
        property>
    bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

使用注解

需要配置config去代替之前的spring配置文件

//使用此类以后相当于替换了配置文件，完全不使用配置文件的纯注解开发
@Configuration//相当于配置文件的外壳
@ComponentScan({"dao","aop"})
//可以配置多个扫描路径eg:
//@ComponentScan({"wwr.dao",“com.wwr”})
@EnableAspectJAutoProxy
//此注解用于aop，不支持*通配符，配置属性文件，其他地方使用时：@Value("${}")
public class Config {


}
1
2
3
4
5
6
7
8
9
10
11

AOP—面向切面编程

• AOP：面向切面编程
• 作用：不惊动原始设计的基础上为其进行功能增强
• Spring理念：无入侵式
• 被增强的功能叫做连接点，增强的共性功能叫做通知，
• 匹配连接点的式子就是切入点
• 切面描述的就是在那个切入点上连接哪些通知
• 通知类是定义通知的类
• 实现原理：代理
• 切入点描述
  AOP的通知分5中类型
• 前置通知
• 后置通知
• 环绕通知
• 返回后通知
• 抛出异常后通知
  切面编程的小例子
  切面编程除了在使用spring自带的依赖外还需要添加

 <dependency>
            <groupId>org.aspectjgroupId>
            <artifactId>aspectjweaverartifactId>
            <version>1.9.7version>
        dependency>
1
2
3
4
5

@Component("function1")
public class function1 {

    public void save(){
        System.out.println("你以为你拒绝的是谁的爱");
    }
    public void update(){
        System.out.println("是一个天神的爱");
    }
}
1
2
3
4
5
6
7
8
9
10

这里的function1是需要被增强功能的类，我们选择对update进行增强

@Component
@Aspect
public class no1Aop {
    @Pointcut("execution(void dao.function1.update())")
    //切入点描述：
    /**
     * 返回值
     * 包名
     * 类/接口
     * 方法名
     * 参数
     * 异常名
     * 可以使用通配符
     *
     */
    private void ps(){

    }
    @After("ps()")
    public void method(){
        System.out.println("他为你忍受一切痛苦，带给你欢乐");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

主要说一下环绕通知

这里的环绕通知他需要先执行一次增强方法，再去执行原始方法，再去执行增强方法
* 注意！你如果切入点有返回值一定要把通知的返回值设置为Object
* 环绕方法如果切入点有返回值，你这个通知需要也有返回值，最好使用Object proceed = pj.proceed();进行接收，再返回

具体：

    @Around("ps()")
    public Object method2(ProceedingJoinPoint pj) throws Throwable {
        System.out.println("1");
        Object proceed = pj.proceed();//就表示执行原方法并获取原方法的参数，如果没有参数你直接pj.proceed()就可以的把Object改成VOID
        System.out.println("2");
        return proceed;
    }
1
2
3
4
5
6
7

你那个被增强的方法就是切入点也需要有参数
就像这样：

@Component("function1")
public class function1 {
    public int update(int a){
        System.out.println("是一个天神的爱");
        return a;
    }
}
1
2
3
4
5
6
7

注意你的Config配置类
需要添加注解@EnableAspectJAutoProxy，不添加此注解没有办法解析@Aspect，还需要注意你的Config配置类的@ComponentScan({“dao”,“aop”})
看他是否扫描到了你的aop和被增强功能的那个类。

欲知后事如何，请听下回分解~ ~ ~客官您慢走