关于 Spring 的示例

示例一：spring 基本

① 创建项目并导入包

② 创建一个实体类 HelloWorldService.java

1 package cn.mgy.service;
2 
3 public class HelloWorldService {
4     public void say() {
5         System.out.println("--你好世界--");
6     }
7 }

③ 创建一个配置类 applicationContent.xml

1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
5 
6     <!-- <bean>标签：用于声明一个类，在启动 Spring 框架的时候根据该配置的类创建对象到spring容器里面 -->
7     <bean name="helloWorldService" class="cn.mgy.service.HelloWorldService"></bean>
8 </beans>

④ 创建一个测试类 HelloWorldServiceTest.java

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.beans.BeansException;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 
 7 import cn.mgy.service.HelloWorldService;
 8 
 9 public class HelloWorldServiceTest {
10 
11     @Test
12     public void say() {
13         try {
14             // 创建一个 ApplicationContext 对象，根据 xml 配置创建一个对象
15             // 直接读取 Spring 的 src 目录下配置文件的子类是 ClassPathXmlApplicationContext
16             ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
17             HelloWorldService helloWorldService = context.getBean("helloWorldService",HelloWorldService.class);
18             // 调用方法
19             helloWorldService.say();
20             // 结束程序，可以关闭容器
21             context.close();
22         } catch (BeansException e) {
23             e.printStackTrace();
24         }
25     }
26 }

⑤ 运行结果

示例二：控制反转（IoC）

① 创建项目并导入包

② 创建一个接口 CustomerService.java

1 package cn.mgy.service;
2 
3 public interface CustomerService {
4     /**
5      * 保存方法
6      */
7     void save();
8 }

③ 创建两个实现接口的类 CustomerServiceImpl1.java 和 CustomerServiceImpl2.java

 1 package cn.mgy.service.impl;
 2 
 3 import cn.mgy.service.CustomerService;
 4 
 5 public class CustomerServiceImpl1 implements CustomerService {
 6 
 7     @Override
 8     public void save() {
 9         System.out.println("--保存客户-CustomerServiceImpl1--");
10     }
11 
12 }

 1 package cn.mgy.service.impl;
 2 
 3 import cn.mgy.service.CustomerService;
 4 
 5 public class CustomerServiceImpl2 implements CustomerService {
 6 
 7     @Override
 8     public void save() {
 9         System.out.println("--保存客户-CustomerServiceImpl2--");
10     }
11 
12 }

④ 创建一个调用方的类 CustomerClient.java

 1 package cn.mgy.client;
 2 
 3 import cn.mgy.service.CustomerService;
 4 
 5 public class CustomerClient {
 6     
 7     // 1、声明一个父接口的引用
 8     private CustomerService customerService;
 9     
10     // 2、使用 set 方法注入对象，我们将通过方法注入的对象的方式称为依赖注入
11     public void setCustomerService(CustomerService customerService) {
12         this.customerService = customerService;
13     }
14     
15     public void login() {
16         // 调用服务端的方法
17         customerService.save();
18     }
19 }

⑤ 创建配置文件 applicationContent.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5 
 6     <!-- <bean>标签：用于声明一个类，在启动 Spring 框架的时候根据该配置的类创建对象到spring容器里面 -->
 7     <!-- <bean name="customerServiceImpl" class="cn.mgy.service.impl.CustomerServiceImpl1"></bean> -->
 8     <!-- 
 9         CustomerServiceImpl1 修改为 CustomerServiceImpl2 的配置
10      -->
11     <bean name="customerServiceImpl" class="cn.mgy.service.impl.CustomerServiceImpl2"></bean>
12     <bean name="customerClient" class="cn.mgy.client.CustomerClient">
13         <!-- 
14             对应  set 方法关联的对象 customerService
15                 name：关联对应的 set 方法，关联规则：xxx 对应 setXxx(); 如：customerService() 对应 setCustomerService()
16                 ref：指向容器中的对象
17          -->
18          <property name="customerService" ref="customerServiceImpl"></property>
19     </bean>
20 </beans>

⑥ 创建一个测试类 ClientTest.java

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5 
 6 import cn.mgy.client.CustomerClient;
 7 
 8 public class ClientTest {
 9     
10     @Test
11     public void save() {
12         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
13         CustomerClient customerClient = context.getBean("customerClient",CustomerClient.class);
14         // 调用方法
15         customerClient.login();
16         // 关闭容器
17         context.close();
18     }
19 }

⑦ 测试结果

示例三：通过 set 方法实现依赖注入

① 创建项目并导入包

② 创建一个带 set 方法的类 CustomerService.java

 1 package cn.mgy.service;
 2 
 3 import import java.util.Date;
 4 
 5 public class CustomerService {
 6 
 7     private int age;
 8     private String name;
 9     private Date birthDate;
10 
11     public void setAge(int age) {
12         this.age = age;
13     }
14 
15     public void setName(String name) {
16         this.name = name;
17     }
18 
19     public void setBirthDate(Date birthDate) {
20         this.birthDate = birthDate;
21     }
22 
23     public void reigster() {
24         System.out.println("姓名："+name);
25         System.out.println("年龄："+age);
26         System.out.println("生日："+birthDate);
27     }
28 }

③ 创建配置文件 applicationContent.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5 
 6     <bean name="now" class="java.util.Date"></bean>
 7     <bean name="customerService" class="cn.mgy.service.CustomerService">
 8         <!-- 一个 property 标签匹配一个 set 方法  -->
 9         <!-- 
10             只要是标量类型，可以使用 value 设置，
11             注意：所谓的标量类型就是基础数据类型（以及包装类）+ String 类型
12             如果非标量类型，必须使用 ref 引用对象
13          -->
14          <property name="name" value="张三" />
15          <property name="age" value="15" />
16          <property name="birthDate" ref="now" />
17     </bean>
18 </beans>

④ 创建一个测试类

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5 
 6 import cn.mgy.service.CustomerService;
 7 
 8 public class ClientTest {
 9     
10     @Test
11     public void test() {
12         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
13         CustomerService customerService = context.getBean("customerService",CustomerService.class);
14         // 调用方法
15         customerService.reigster();
16         // 关闭容器
17         context.close();
18     }
19 }

⑤ 测试结果

示例四：通过构造方法进行依赖注入

① 创建一个项目并导入包

② 创建一个带构造方法的类 CustomerService.java

 1 package cn.mgy.service;
 2 
 3 import java.util.Date;
 4 
 5 public class CustomerService {
 6 
 7     private String name;
 8     private int age;
 9     private Date birthDate;
10 
11     /**
12      * 声明一个有参数的构造方法
13      * @param age
14      * @param name
15      * @param birthDate
16      */
17     public CustomerService( String name, int age,Date birthDate) {
18         super();
19         this.name = name;
20         this.age = age;
21         this.birthDate = birthDate;
22     }
23 
24     public void reigster() {
25         System.out.println("姓名："+name);
26         System.out.println("年龄："+age);
27         System.out.println("生日："+birthDate);
28     }
29 }

③ 创建配置文件 applicationContent.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5 
 6     <bean name="now" class="java.util.Date"></bean>
 7     <bean name="customerService" class="cn.mgy.service.CustomerService">
 8         <!-- 
 9             构造函数每一个参数：对应一个 constructor-arg 标签
10             name：指定参数名
11             value：指定注入的值
12             ref：指定引用的对象
13             index：指定参数的位置
14             type：指定参数的数据类型，默认使用参数声明的类型[可以忽略]
15          -->        
16          <constructor-arg name="name" type="java.lang.String" value="张三" />
17          <constructor-arg name="age" value="15" />
18          <constructor-arg name="birthDate" ref="now" />
19          
20          <!-- 通过位置指定参数 -->
21          <!-- <constructor-arg index="0" type="java.lang.String" value="张三" />
22          <constructor-arg index="1" value="15" />
23          <constructor-arg index="2" ref="now" /> -->
24     </bean>
25 </beans>

④ 创建一个测试类

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.beans.BeansException;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 
 7 import cn.mgy.service.CustomerService;
 8 
 9 public class ClientTest {
10     
11     @Test
12     public void test() {
13         try {
14             ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
15             CustomerService customerService = context.getBean("customerService",CustomerService.class);
16             // 调用方法
17             customerService.reigster();
18             // 关闭容器
19             context.close();
20         } catch (BeansException e) {
21             // TODO Auto-generated catch block
22             e.printStackTrace();
23         }
24     }
25 }

⑤ 测试结果

示例五：通过 p 标签实现依赖注入

① 创建项目并导入包

② 创建一个带 set 方法的类 CustomerService.java

 1 package cn.mgy.service;
 2 
 3 import java.util.Date;
 4 
 5 public class CustomerService {
 6 
 7     private int age;
 8     private String name;
 9     private Date birthDate;
10 
11     public void setAge(int age) {
12         this.age = age;
13     }
14 
15     public void setName(String name) {
16         this.name = name;
17     }
18 
19     public void setBirthDate(Date birthDate) {
20         this.birthDate = birthDate;
21     }
22 
23     public void reigster() {
24         System.out.println("姓名："+name);
25         System.out.println("年龄："+age);
26         System.out.println("生日："+birthDate);
27     }
28 }

③ 创建配置文件 applicationContent.xml

1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4     xmlns:p="http://www.springframework.org/schema/p"
5     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
6     <bean name="now" class="java.util.Date"></bean>
7     <bean name="customerService" class="cn.mgy.service.CustomerService" p:name="张三" p:age="15" p:birthDate-ref="now"></bean>
8 </beans>

④ 创建一个测试类

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.beans.BeansException;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 
 7 import cn.mgy.service.CustomerService;
 8 
 9 public class ClientTest {
10     
11     @Test
12     public void test() {
13         try {
14             ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
15             CustomerService customerService = context.getBean("customerService",CustomerService.class);
16             // 调用方法
17             customerService.reigster();
18             // 关闭容器
19             context.close();
20         } catch (BeansException e) {
21             // TODO Auto-generated catch block
22             e.printStackTrace();
23         }
24     }
25 }

⑤ 测试结果

示例六：注入集合数据

① 创建一个项目并导入包

② 创建一个带 set 方法的类 CustomerService.java

 1 package cn.mgy.service;
 2 
 3 import java.util.Arrays;
 4 import java.util.List;
 5 import java.util.Map;
 6 import java.util.Properties;
 7 import java.util.Set;
 8 
 9 public class CustomerService {
10 
11     private String[] myStrs;
12     private List<String> myList;
13     private Set<String> mySet;
14     private Map<String, Object> myMap;
15     private Properties myProperties;
16 
17     public void setMyStrs(String[] myStrs) {
18         this.myStrs = myStrs;
19     }
20 
21     public void setMyList(List<String> myList) {
22         this.myList = myList;
23     }
24 
25     public void setMySet(Set<String> mySet) {
26         this.mySet = mySet;
27     }
28 
29     public void setMyMap(Map<String, Object> myMap) {
30         this.myMap = myMap;
31     }
32 
33     public void setMyProperties(Properties myProperties) {
34         this.myProperties = myProperties;
35     }
36     
37     public void reigster() {
38         System.out.println(Arrays.toString(myStrs));
39         System.out.println(myList);
40         System.out.println(mySet);
41         System.out.println(myMap);
42         System.out.println(myProperties);
43     }
44 }

③ 创建配置文件 applicationContent.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:p="http://www.springframework.org/schema/p"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 6     <bean name="now" class="java.util.Date" />
 7     <bean name="customerService" class="cn.mgy.service.CustomerService">
 8         <property name="myStrs">
 9             <array>
10                 <value>AAA</value>
11                 <value>BBB</value>
12                 <value>CCC</value>
13             </array>
14         </property>
15         <property name="mySet">
16             <set>
17                 <value>AAA</value>
18                 <value>BBB</value>
19                 <value>CCC</value>
20             </set>
21         </property>
22         <property name="myList">
23             <list>
24                 <value>AAA</value>
25                 <value>BBB</value>
26                 <value>CCC</value>
27             </list>
28         </property>
29         <property name="myMap">
30             <map>
31                 <entry key="id" value="1" />
32                 <entry key="name" value="张三" />
33                 <entry key="birthDate" value="now" />
34             </map>
35         </property>
36         <property name="myProperties">
37             <props>
38                 <prop key="id">1</prop>
39                 <prop key="name">张三</prop>
40             </props>
41         </property>
42     </bean>
43 </beans>

④ 创建一个测试类

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.beans.BeansException;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 
 7 import cn.mgy.service.CustomerService;
 8 
 9 public class ClientTest {
10     
11     @Test
12     public void test() {
13         try {
14             ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
15             CustomerService customerService = context.getBean("customerService",CustomerService.class);
16             // 调用方法
17             customerService.reigster();
18             // 关闭容器
19             context.close();
20         } catch (BeansException e) {
21             // TODO Auto-generated catch block
22             e.printStackTrace();
23         }
24     }
25 }

⑤ 测试结果

示例七：通过Properties文件的Key获得对应的值

① 创建一个项目并导入包

② 创建一个带 set 方法的类 CustomerService.java

 1 package cn.mgy.service;
 2 
 3 import java.util.Date;
 4 
 5 public class CustomerService {
 6 
 7     private int age;
 8     private String name;
 9     private Date birthDate;
10 
11     public void setAge(int age) {
12         this.age = age;
13     }
14 
15     public void setName(String name) {
16         this.name = name;
17     }
18 
19     public void setBirthDate(Date birthDate) {
20         this.birthDate = birthDate;
21     }
22 
23     public void reigster() {
24         System.out.println("姓名："+name);
25         System.out.println("年龄："+age);
26         System.out.println("生日："+birthDate);
27     }
28 }

③ 创建 properties 文件 sys.properties

customer.name = 张三
customer.age = 20

④ 创建配置文件 applicationContent.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5     
 6     <!-- 指定 Properties 配置文件的路径 -->
 7     <bean class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
 8         <property name="locations" value="classpath:sys.properties" />
 9         <property name="fileEncoding" value="UTF-8" />
10     </bean>
11     
12     <bean name="now" class="java.util.Date"></bean>
13     <bean name="customerService" class="cn.mgy.service.CustomerService">
14         <!-- 一个 property 标签匹配一个 set 方法  -->
15         <!-- 
16             只要是标量类型，可以使用 value 设置，
17             注意：所谓的标量类型就是基础数据类型（以及包装类）+ String 类型
18             如果非标量类型，必须使用 ref 引用对象
19          -->
20          <property name="name" value="${customer.name}" />
21          <property name="age" value="${customer.age}" />
22          <property name="birthDate" ref="now" />
23     </bean>
24 </beans>

⑤ 创建一个测试类

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.beans.BeansException;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 
 7 import cn.mgy.service.CustomerService;
 8 
 9 public class ClientTest {
10     
11     @Test
12     public void test() {
13         try {
14             ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
15             CustomerService customerService = context.getBean("customerService",CustomerService.class);
16             // 调用方法
17             customerService.reigster();
18             // 关闭容器
19             context.close();
20         } catch (BeansException e) {
21             // TODO Auto-generated catch block
22             e.printStackTrace();
23         }
24     }
25 }

⑥ 测试结果

示例八：基于注解的Spring开始

① 创建一个项目并导入包

② 创建配置文件 applicationContent.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:context="http://www.springframework.org/schema/context"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 6         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
 7 
 8     <!-- 声明扫描包以及子包的类。如果发现有组件注解的类，就创建对象，并加入到容器 -->
 9     <context:component-scan base-package="cn.mgy" />
10 </beans>

③ 创建一个类 CustomerService.java

 1 package cn.mgy.service;
 2 
 3 import org.springframework.stereotype.Service;
 4 
 5 // 1、使用注解配置，需要将启动就创建对象的类标注为组件类
 6 @Service
 7 public class HelloWorldService {
 8     public void say() {
 9         System.out.println("--你好世界--");
10     }
11 }

④ 创建一个测试类

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.beans.BeansException;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 
 7 import cn.mgy.service.HelloWorldService;
 8 
 9 public class HelloWorldServiceTest {
10 
11     @Test
12     public void say() {
13         try {
14             // 创建一个 ApplicationContext 对象，根据 xml 配置创建一个对象
15             // 直接读取 Spring 的 src 目录下配置文件的子类是 ClassPathXmlApplicationContext
16             ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
17             HelloWorldService helloWorldService = context.getBean("helloWorldService",HelloWorldService.class);
18             // 调用方法
19             helloWorldService.say();
20             // 结束程序，可以关闭容器
21             context.close();
22         } catch (BeansException e) {
23             e.printStackTrace();
24         }
25     }
26 }

⑤ 测试结果

示例九：Spring 基本注解的使用

① 创建一个项目并导入包

② 创建一个实体类 User.java

 1 package cn.mgy.pojo;
 2 
 3 public class User {
 4     private Long userId;//BIGINT(20) NOT NULL AUTO_INCREMENT,
 5     private String userName;//VARCHAR(100) NULL DEFAULT NULL,
 6     private String userPwd;//VARCHAR(100) NULL DEFAULT NULL,
 7     private String userSex;//CHAR(2) NULL DEFAULT NULL,
 8     private Integer userAge;//INT(3) NULL DEFAULT NULL,
 9     private String userBirth;//DATE NULL DEFAULT NULL,
10     public Long getUserId() {
11         return userId;
12     }
13     public void setUserId(Long userId) {
14         this.userId = userId;
15     }
16     public String getUserName() {
17         return userName;
18     }
19     public void setUserName(String userName) {
20         this.userName = userName;
21     }
22     public String getUserPwd() {
23         return userPwd;
24     }
25     public void setUserPwd(String userPwd) {
26         this.userPwd = userPwd;
27     }
28     public String getUserSex() {
29         return userSex;
30     }
31     public void setUserSex(String userSex) {
32         this.userSex = userSex;
33     }
34     public Integer getUserAge() {
35         return userAge;
36     }
37     public void setUserAge(Integer userAge) {
38         this.userAge = userAge;
39     }
40     public String getUserBirth() {
41         return userBirth;
42     }
43     public void setUserBirth(String userBirth) {
44         this.userBirth = userBirth;
45     }
46 }

③ 创建连接数据库的四要素文件 db.properties

#连接数据库的四要素
db.driverName = org.gjt.mm.mysql.Driver
db.url = jdbc:mysql://localhost:3306/test
db.userName = root
db.password = root

④ 创建配置文件 applicationContent.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:context="http://www.springframework.org/schema/context"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 6         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
 7     
 8     <!-- 指定 Properties 配置文件的路径 -->
 9     <bean class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
10         <property name="locations" value="classpath:db.properties" />
11         <property name="fileEncoding" value="UTF-8" />
12     </bean>
13     
14     <!-- 声明扫描包以及子包的类。如果发现有组件注解的类，就创建对象，并加入到容器 -->
15     <context:component-scan base-package="cn.mgy" />
16     
17 </beans>

⑤ 创建持久层的接口 UserDao.java 与实现类 UserDaoImpl.java

 1 package cn.mgy.dao;
 2 
 3 import cn.mgy.pojo.User;
 4 
 5 public interface UserDao {
 6     /**
 7      * 插入一条数据
 8      * @param user
 9      * @return
10      */
11     int insert(User user);
12 }

 1 package cn.mgy.dao.impl;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.PreparedStatement;
 6 
 7 import org.springframework.beans.factory.annotation.Value;
 8 import org.springframework.stereotype.Repository;
 9 
10 import cn.mgy.dao.UserDao;
11 import cn.mgy.pojo.User;
12 
13 // @Repository：用于声明持久层的组件注解
14 @Repository
15 public class UserDaoImpl implements UserDao {
16     
17     // @Value 注解：注入基本数据类型和String类型的数据
18     @Value(value="${db.driverName}")
19     private String driver;
20     @Value(value="${db.url}")
21     private String url;
22     @Value(value="${db.userName}")
23     private String userName;
24     @Value(value="${db.password}")
25     private String password;
26 
27     @Override
28     public int insert(User user) {
29         try {
30             Class.forName(driver);
31             Connection conn = DriverManager.getConnection(url, userName, password);
32             String sql = "INSERT INTO t_user(user_name, user_pwd, user_sex, user_age) VALUES (?, ?, ?, ?)";
33             PreparedStatement prepareStatement = conn.prepareStatement(sql);
34             prepareStatement.setString(1, user.getUserName());
35             prepareStatement.setString(2, user.getUserPwd());
36             prepareStatement.setString(3, user.getUserSex());
37             prepareStatement.setInt(4, user.getUserAge());
38             int i = prepareStatement.executeUpdate();
39             return i;
40         } catch (Exception e) {
41             e.printStackTrace();
42         }
43         
44         return 0;
45     }
46 
47 }

⑥ 创建服务层接口 UserService.java 与实现类 UserServiceImpl.java

 1 package cn.mgy.service;
 2 
 3 import cn.mgy.pojo.User;
 4 
 5 public interface UserService {
 6     
 7     /**
 8      * 保存用户
 9      */
10     int save(User user);
11 }

 1 package cn.mgy.service.impl;
 2 
 3 import javax.annotation.PostConstruct;
 4 import javax.annotation.PreDestroy;
 5 
 6 import org.springframework.beans.factory.annotation.Autowired;
 7 import org.springframework.beans.factory.annotation.Qualifier;
 8 import org.springframework.context.annotation.Scope;
 9 import org.springframework.stereotype.Service;
10 
11 import cn.mgy.dao.UserDao;
12 import cn.mgy.pojo.User;
13 import cn.mgy.service.UserService;
14 
15 // @Service：用于声明服务层的组件注解
16 @Service
17 // @Scope 注解：指定 bean 的作用范围
18 // 属性：value 指定范围的值
19 // 取值： singleton：单例
20 //           对象出生：当程序加载配置文件创建容器时，创建
21 //           对象活着：只要容器还在，一直活着
22 //           对象死亡：应用停止，容器销毁，对象死亡
23 //      prototype：原型（多例）
24 //           对象出生：当程序加载配置文件创建容器时，创建
25 //           对象活着：只要对象被使用，一直活着
26 //           对象死亡：对象长时间不用，会被Java垃圾回收机制回收
27 
28 //      request：web项目中，Spring将创建的对象放在request作用域中
29 //      session：web项目中，Spring将创建的对象放在session作用域中
30 @Scope(value="singleton")
31 public class UserServiceImpl implements UserService {
32 
33     // @Autowired 注解：用于给引用注入容器的对象
34     // @Qualifier 注解：用于指定注入的对象名，使用 @Autowired 注入对象时，
35     // @Autowired 没有指定对象的属性，只能通过 @Qualifier 字段指定容器中的对象名
36     // 也可以使用 @Resource 注解代替为 @Resource(name="userDao")
37     @Autowired
38     @Qualifier(value="userDaoImpl")
39     private UserDao userDao;
40     
41     @Override
42     public int save(User user) {
43         int i = userDao.insert(user);
44         if (i > 0) {
45             return i;
46         } else {
47             return 0;
48         }
49     }
50 
51     // @PostConstruct 注解等同于 <bean init-method="">：用于指定初始化方法
52     // 对象初始化方法
53     @PostConstruct
54     public void init() {
55         System.out.println("初始化必须调用该方法");
56     }
57     
58     // @PreDestroy 注解等同于 <bean destroy-method="">：用于指定销毁方法
59     // 对象注销前，必须调用的方法
60     @PreDestroy
61     public void destroy() {
62         System.out.println("注销前必须调用该方法");
63     }
64 }

⑦ 创建表示层类 UserController.java

 1 package cn.mgy.controller;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Controller;
 5 
 6 import cn.mgy.pojo.User;
 7 import cn.mgy.service.UserService;
 8 
 9 // 表示层使用 @Controller
10 // 如果组件注解不声明对象名，就使用默认命名法
11 // 所谓默认命名就是将类的首字母小写作为类的对象名
12 // 组件注解
13     // 属性 value：作用用于指定该类对象的自定义对象名
14 @Controller(value="userController")
15 public class UserController {
16 
17     // @Autowired 注解：用于给引用注入容器的对象
18     @Autowired
19     private UserService userService;
20     
21     public void save() {
22         User user = new User();
23         user.setUserName("李四");
24         user.setUserPwd("12345");
25         user.setUserSex("男");
26         user.setUserAge(18);
27         if (userService.save(user)>0) {            
28             System.out.println("--保存用户成功--");
29         } else {
30             System.out.println("--保存用户失败--");
31         }
32     }
33 }

⑧ 创建一个测试类 UserTest.java

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.beans.BeansException;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 
 7 import cn.mgy.controller.UserController;
 8 
 9 public class UserTest {
10     
11     @Test
12     public void test() {
13         try {
14             ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContent.xml");
15             UserController userController = context.getBean("userController",UserController.class);
16             // 调用方法
17             userController.save();
18             // 关闭容器
19             context.close();
20         } catch (BeansException e) {
21             // TODO Auto-generated catch block
22             e.printStackTrace();
23         }
24     }
25 }

⑨ 运行结果

示例十：Spring 纯注解的操作

① 创建一个项目并导入包

② 创建一个连接数据库的四要素文件 db.properties

#连接数据库的四要素
db.driverName = org.gjt.mm.mysql.Driver
db.url = jdbc:mysql://localhost:3306/test
db.userName = root
db.password = root

③ 创建一个配置类 BeanConfig.java

 1 package cn.mgy.config;
 2 
 3 import org.springframework.context.annotation.ComponentScan;
 4 import org.springframework.context.annotation.Configuration;
 5 import org.springframework.context.annotation.PropertySource;
 6 // @Configuration 配置类注解，在纯注解配置中，类加了该注解，就意味着该类是 Sping 的配置类。
 7 // 该类的功能就是用于代替原来的 XML 配置文件
 8 // 作用：用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。
 9 // 获取容器时需要使用 AnnotationConfigApplicationContext(有 @Configuration 注解的类.class)
10 @Configuration
11 // @ComponentScan 注解：用于指定 spring 在初始化容器时扫描的包。作用和在 spring 的 xml 配置文件中的：
12 // <context:component-scan base-package="cn.mgy"/>是一样的
13 @ComponentScan(basePackages= {"cn.mgy"})
14 // @PropertySource 注解：用于加载 .properties 文件中的配置。
15 // 属性：value[]：用于指定 properties 文件的位置
16 @PropertySource(encoding="UTF-8",value= {"classpath:db.properties"})
17 public class BeanConfig {
18 
19 }

④ 创建持久层的接口 UserDao.java 和实现类 UserDaoImpl.java

 1 package cn.mgy.dao;
 2 
 3 import java.util.List;
 4 
 5 import cn.mgy.pojo.User;
 6 
 7 public interface UserDao {
 8     /**
 9      * 查询所有用户
10      * @return
11      */
12     List<User> selectAllUser();
13 }

 1 package cn.mgy.dao.impl;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.PreparedStatement;
 6 import java.sql.ResultSet;
 7 import java.util.ArrayList;
 8 import java.util.List;
 9 
10 import org.springframework.beans.factory.annotation.Value;
11 import org.springframework.stereotype.Repository;
12 
13 import cn.mgy.dao.UserDao;
14 import cn.mgy.pojo.User;
15 
16 // @Repository：用于声明持久层的组件注解
17 @Repository
18 public class UserDaoImpl implements UserDao {
19     
20     // @Value 注解：注入基本数据类型和String类型的数据
21     @Value(value="${db.driverName}")
22     private String driver;
23     @Value(value="${db.url}")
24     private String url;
25     @Value(value="${db.userName}")
26     private String userName;
27     @Value(value="${db.password}")
28     private String password;
29 
30     @Override
31     public List<User> selectAllUser() {
32         try {
33             Class.forName(driver);
34             Connection conn = DriverManager.getConnection(url, userName, password);
35             String sql = "SELECT * FROM t_user";
36             PreparedStatement prepareStatement = conn.prepareStatement(sql);
37             ResultSet resultSet = prepareStatement.executeQuery();
38             List<User> users = new ArrayList<>();
39             while(resultSet.next()) {
40                 User user = new User();
41                 user.setUserId(resultSet.getLong(1));
42                 user.setUserName(resultSet.getString(2));
43                 user.setUserPwd(resultSet.getString(3));
44                 user.setUserSex(resultSet.getString(4));
45                 user.setUserAge(resultSet.getInt(5));
46                 users.add(user);
47             }
48             return users;
49         } catch (Exception e) {
50             e.printStackTrace();
51         }
52         return null;
53     }
54 
55 }

⑤ 创建服务层的接口 UserService.java 与实现类 UserServiceImpl.java

 1 package cn.mgy.service;
 2 
 3 import java.util.List;
 4 
 5 import cn.mgy.pojo.User;
 6 
 7 public interface UserService {
 8     
 9     /**
10      * 查询所有用户
11      * @return
12      */
13     List<User> selectAllUser();
14 }

 1 package cn.mgy.service.impl;
 2 
 3 import java.util.List;
 4 
 5 import javax.annotation.PostConstruct;
 6 import javax.annotation.PreDestroy;
 7 
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 import org.springframework.beans.factory.annotation.Qualifier;
10 import org.springframework.context.annotation.Scope;
11 import org.springframework.stereotype.Service;
12 
13 import cn.mgy.dao.UserDao;
14 import cn.mgy.pojo.User;
15 import cn.mgy.service.UserService;
16 
17 // @Service：用于声明服务层的组件注解
18 @Service
19 // @Scope 注解：指定 bean 的作用范围
20 // 属性：value 指定范围的值
21 // 取值： singleton：单例
22 //           对象出生：当程序加载配置文件创建容器时，创建
23 //           对象活着：只要容器还在，一直活着
24 //           对象死亡：应用停止，容器销毁，对象死亡
25 //      prototype：原型（多例）
26 //           对象出生：当程序加载配置文件创建容器时，创建
27 //           对象活着：只要对象被使用，一直活着
28 //           对象死亡：对象长时间不用，会被Java垃圾回收机制回收
29 
30 //      request：web项目中，Spring将创建的对象放在request作用域中
31 //      session：web项目中，Spring将创建的对象放在session作用域中
32 @Scope(value="singleton")
33 public class UserServiceImpl implements UserService {
34 
35     // @Autowired 注解：用于给引用注入容器的对象
36     // @Qualifier 注解：用于指定注入的对象名，使用 @Autowired 注入对象时，
37     // @Autowired 没有指定对象的属性，只能通过 @Qualifier 字段指定容器中的对象名
38     // 也可以使用 @Resource 注解代替为 @Resource(name="userDao")
39     @Autowired
40     @Qualifier(value="userDaoImpl")
41     private UserDao userDao;
42     
43     @Override
44     public List<User> selectAllUser() {
45         List<User> selectAllUser = userDao.selectAllUser();
46         if (selectAllUser != null) {
47             return selectAllUser;
48         } else {
49             return null;
50         }
51     }
52 
53     // @PostConstruct 注解等同于 <bean init-method="">：用于指定初始化方法
54     // 对象初始化方法
55     @PostConstruct
56     public void init() {
57         System.out.println("初始化必须调用该方法");
58     }
59     
60     // @PreDestroy 注解等同于 <bean destroy-method="">：用于指定销毁方法
61     // 对象注销前，必须调用的方法
62     @PreDestroy
63     public void destroy() {
64         System.out.println("注销前必须调用该方法");
65     }
66 }

⑥ 创建表示层的类 UserController.java

 1 package cn.mgy.controller;
 2 
 3 import java.util.List;
 4 
 5 import javax.annotation.Resource;
 6 
 7 import org.springframework.stereotype.Controller;
 8 
 9 import cn.mgy.pojo.User;
10 import cn.mgy.service.UserService;
11 
12 @Controller
13 public class UserController {
14 
15     @Resource(name="userServiceImpl")
16     private UserService userService;
17     
18     public void selectAllUser() {
19         List<User> allUser = userService.selectAllUser();
20         if (allUser != null) {
21             for (User user : allUser) {
22                 System.out.println("用户编号："+user.getUserId());
23                 System.out.println("用户姓名："+user.getUserName());
24                 System.out.println("用户密码："+user.getUserPwd());
25                 System.out.println("用户性别："+user.getUserSex());
26                 System.out.println("用户年龄："+user.getUserAge());
27             }
28         } else {
29             System.err.println("查询出错");
30         }
31     }
32 }

⑦ 创建一个测试类 UserTest.java

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.springframework.beans.BeansException;
 5 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 6 
 7 import cn.mgy.config.BeanConfig;
 8 import cn.mgy.controller.UserController;
 9 
10 public class UserTest {
11 
12     @Test
13     public void selectAllUser() {
14         try {
15             // 注意：读取注解配置类的容器类为 AnnotationConfigApplicationContext
16             AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
17             UserController userController = context.getBean("userController",UserController.class);
18             userController.selectAllUser();
19             context.close();
20         } catch (BeansException e) {
21             e.printStackTrace();
22         }
23     }
24 }

⑧ 运行结果

示例十一：Spring 整合 Junit

① 创建一个项目并导入包

② 创建一个带 set 方法的类 CustomerService.java

 1 package cn.mgy.service;
 2 
 3 import java.util.Date;
 4 
 5 public class CustomerService {
 6 
 7     private int age;
 8     private String name;
 9     private Date birthDate;
10 
11     public void setAge(int age) {
12         this.age = age;
13     }
14 
15     public void setName(String name) {
16         this.name = name;
17     }
18 
19     public void setBirthDate(Date birthDate) {
20         this.birthDate = birthDate;
21     }
22 
23     public void reigster() {
24         System.out.println("姓名："+name);
25         System.out.println("年龄："+age);
26         System.out.println("生日："+birthDate);
27     }
28 }

③ 创建配置文件 applicationContent.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5 
 6     <bean name="now" class="java.util.Date"></bean>
 7     <bean name="customerService" class="cn.mgy.service.CustomerService">
 8         <!-- 一个 property 标签匹配一个 set 方法  -->
 9         <!-- 
10             只要是标量类型，可以使用 value 设置，
11             注意：所谓的标量类型就是基础数据类型（以及包装类）+ String 类型
12             如果非标量类型，必须使用 ref 引用对象
13          -->
14          <property name="name" value="张三" />
15          <property name="age" value="15" />
16          <property name="birthDate" ref="now" />
17     </bean>
18 </beans>

④ 创建一个测试类

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.junit.runner.RunWith;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.test.context.ContextConfiguration;
 7 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 8 
 9 import cn.mgy.service.CustomerService;
10 
11 // 指定 Junit 测试之前，加入 Spring 框架启动的逻辑代码
12 @RunWith(SpringJUnit4ClassRunner.class)
13 // 指定 Spring 启动必须的配置文件
14 // 注意：配置文件通过 locations 指定
15 @ContextConfiguration(locations="classpath:applicationContent.xml")
16 public class CustomerServiceTest {
17     
18     // 获得 Spring 容器中的对象
19     @Autowired
20     private CustomerService customerService;
21     
22     @Test
23     public void reigster() {
24         try {
25             customerService.reigster();
26         } catch (Exception e) {
27             e.printStackTrace();
28         }
29     }
30 }

⑤ 测试结果

示例十二：基于纯注解的 Spring 整合 Junit

① 创建一个项目并导入包

② 创建一个配置类 BeanConfig.java

 1 package cn.mgy.config;
 2 
 3 import java.util.Date;
 4 
 5 import org.springframework.context.annotation.Bean;
 6 import org.springframework.context.annotation.ComponentScan;
 7 import org.springframework.context.annotation.Configuration;
 8 
 9 @Configuration
10 @ComponentScan("cn.mgy")
11 public class BeanConfig {
12 
13     @Bean
14     public Date now() {
15         return new Date();
16     }
17 }

③ 创建一个类 CustomerService.java

 1 package cn.mgy.service;
 2 
 3 import java.util.Date;
 4 
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.beans.factory.annotation.Qualifier;
 7 import org.springframework.beans.factory.annotation.Value;
 8 import org.springframework.stereotype.Service;
 9 
10 @Service
11 public class CustomerService {
12 
13     @Value("12")
14     private int age;
15     @Value("张三")
16     private String name;
17     @Autowired
18     @Qualifier("now")
19     private Date birthDate;
20 
21     public void setAge(int age) {
22         this.age = age;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public void setBirthDate(Date birthDate) {
30         this.birthDate = birthDate;
31     }
32 
33     public void reigster() {
34         System.out.println("姓名："+name);
35         System.out.println("年龄："+age);
36         System.out.println("生日："+birthDate);
37     }
38 }

④ 创建一个测试类

 1 package cn.mgy.test;
 2 
 3 import org.junit.Test;
 4 import org.junit.runner.RunWith;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.test.context.ContextConfiguration;
 7 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 8 
 9 import cn.mgy.config.BeanConfig;
10 import cn.mgy.service.CustomerService;
11 
12 // 指定 Junit 测试之前，加入 Spring 框架启动的逻辑代码
13 @RunWith(SpringJUnit4ClassRunner.class)
14 // 指定 Spring 启动必须的配置文件
15 // 注意：配置类通过 classes 指定
16 @ContextConfiguration(classes=BeanConfig.class)
17 public class CustomerServiceTest {
18     
19     // 获得 Spring 容器中的对象
20     @Autowired
21     private CustomerService customerService;
22     
23     @Test
24     public void reigster() {
25         try {
26             customerService.reigster();
27         } catch (Exception e) {
28             e.printStackTrace();
29         }
30     }
31 }

⑤ 测试结果

示例十三：动态代理模式

说明：

　　很久之前，工厂是小作坊。客户是直接和工厂老板见面，购买商品的。

　　随着时间的推移，工厂慢慢做大了。工厂的产品统一通过经销商代理出售了，这个时候客户需要购买工厂的商品，只能通过经销商购买。我们通过以下的代码来演示该流程。

① 创建一个项目

② 创建商品接口 IProduct.java 和商品实现类 Product.java

 1 package cn.mgy.proxy;
 2 
 3 /**
 4  * 工厂生产的商品
 5  * 要求有零售价和批发价
 6  * @author Administrator
 7  *
 8  */
 9 public interface IProduct {
10     
11     // 1、零售价
12     void sale(float money);
13     
14     // 2、批发价
15     void wholesale(float money);
16 }

 1 package cn.mgy.proxy;
 2 
 3 public class Product implements IProduct {
 4 
 5     @Override
 6     public void sale(float money) {
 7         System.out.println("零售价："+money);
 8     }
 9 
10     @Override
11     public void wholesale(float money) {
12         System.out.println("批发价："+money);
13     }
14 
15 }

③ 创建一个代理商类

 1 package cn.mgy.proxy;
 2 
 3 import java.lang.reflect.InvocationHandler;
 4 import java.lang.reflect.Method;
 5 import java.lang.reflect.Proxy;
 6 
 7 public class Franchiser implements InvocationHandler {
 8 
 9     private Object source;
10     
11     /**
12      * 创建代理对象，必须传入源对象
13      * @param source
14      * @return
15      */
16     public Object createProxy(Object source) {
17         this.source = source;
18         // 通过 Proxy 创建代理对象，需要 interfaces
19         Class<?>[] interfaces = source.getClass().getInterfaces();
20         // 通过 Proxy 创建代理对象，需要 classLoader
21         ClassLoader classLoader = source.getClass().getClassLoader();
22         /**
23          * 通过 Proxy 创建代理对象
24          * newProxyInstance 
25          * Proxy 的 newProxyInstance 负责给被代理对象创建代理对象
26          * 参数1：ClassLoader(告诉 JVM 到什么地方寻找该类)
27          * 参数2：Class[](一个接口数组，实现该类实现的所有接口)
28          * 参数3：代理处理类(实现了 InvocationHandler 接口的对象都是代理处理类)
29          * 传入 this或Franchiser 就是一个实现了 InvocationHandler 接口的类
30          */
31         // 由 Proxy 生产出来的代理对象 objProxy，继承了被代理类的方法，实现了被代理类的接口，
32         // 并由代理处理类执行代理逻辑
33         return Proxy.newProxyInstance(classLoader, interfaces, this);
34     }
35     
36     /**
37      * 参数：
38      * 1、proxy 代理对象的引用。不一定每次都用得到
39      * 2、method 当前执行的方法对象
40      * 3、args 执行方法所需的参数
41      * 返回值：当前执行方法的返回值
42      */
43     @Override
44     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
45         System.out.println(proxy.getClass());
46         // 获得方法名
47         String name = method.getName();
48         // 方法的第一个参数
49         Float money = (Float)args[0];
50         Object invoke = null;
51         if (name.equals("sale")) {
52             if (money >= 3.0f) {
53                 // 反射的 method.invoke(...) 方法，表示真正执行
54                 invoke = method.invoke(source, money);
55             } else {
56                 System.out.println("--零售没有货，对不起--");
57             }
58         }
59         if (name.equals("wholesale")) {
60             if (money >= 2.0f) {
61                 invoke = method.invoke(source, money);
62             } else {
63                 System.out.println("--批发没有货，对不起--");
64             }
65         }
66         return invoke;
67     }
68 
69 }

④ 创建一个客户类调用

 1 package cn.mgy.proxy;
 2 
 3 public class Client {
 4 
 5     public static void main(String[] args) {
 6         // 1、没有经销商的情况
 7         //IProduct product = new Product();
 8         // 被客户压价
 9         //product.sale(2.0f);
10         //product.wholesale(1.5f);
11         
12         // 2、只能通过代理商获得商品
13         IProduct product = new Product();
14         // 创建一个代理商的对象
15         Franchiser franchiser = new Franchiser();
16         IProduct proxyProduct = (IProduct)franchiser.createProxy(product);
17         proxyProduct.sale(3.0f);
18         proxyProduct.wholesale(1.5f);
19     }
20 }

⑤ 测试结果

　　没有代理商的测试结果：

　　有代理商的测试结果：

示例十四：基于 XML 配置 AOP

说明：

　　AOP 相关术语：

　　Joinpoint(连接点)：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。

　　 ---就是根据规则，可以指定拦截的方法，我们将每一个被拦截的方法称为连接点。

　　Pointcut(切入点)：所谓的切入点，就是拦截方法设置的规则

--所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。

　　Advice(通知/增强，场景：在之前拦截，还是方法执行后拦截呢？)：就是可以设置在方法之前拦截或者方法执行之后拦截或者方法出异常后拦截，或者方法之前和之后都拦截。我们将这些拦截场景称为通知

　　--所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。

通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

　　Aspect(切面)：所谓的切面就是我们的拦截处理类。

　　是切入点和通知（引介）的结合。

　　切入点表达式说明：

　　execution(表达式)：

　　　　表达式语法：execution([修饰符] 返回值类型包名.类名.方法名(参数))

　　　　写法说明：

　　　　　　全匹配方式：

　　　　　　　　public void cn.mgy.service.impl.StudentServiceImpl.reigster()

　　　　　　访问修饰符可以省略：

　　　　　　　　void cn.mgy.service.impl.StudentServiceImpl.reigster()

　　　　　　返回值可以使用 * 号，表示任意返回值：

　　　　　　　　* cn.mgy.service.impl.StudentServiceImpl.reigster()

　　　　　　包名可以使用 * 号，表示任意包，但是有几级包，需要写几个 * ：

　　　　　　　　* *.*.*.*.StudentServiceImpl.reigster()

　　　　　　使用 .. 来表示当前包及其子包：

　　　　　　　　* cn..StudentServiceImpl.reigster()

　　　　　　类名可以使用 * 号，表示任意类：

　　　　　　　　* cn..*.reigster()

　　　　　　方法名可以使用 * 号，表示任意方法：

　　　　　　　　* cn..*.*()

　　　　　　参数列表可以使用 *，表示参数可以是任意数据类型，但是必须要有参数：

　　　　　　　　* cn..*.*(*)

　　　　　　参数列表可以使用 .. 表示有无参数均可，有参数可以是任意类型：

　　　　　　　　* cn..*.*(..)

　　　　　　全通配方式：

　　　　　　　　* *..*.*(..)

　　　　　　* ：通配的是任意的字符串

　　　　　　.. ：如果通配包的时候，就是匹配包以及其子包的类，如果通配是方法参数，就是不限定任何参数

　　　　常用标签说明：

　　　　　　<aop:config>：用于声明开始 aop 的配置

　　　　　　<aop:aspect>：用于配置切面

　　　　　　　　属性：

　　　　　　　　　　id：给切面提供一个唯一标识

　　　　　　　　　　ref：引用配置好的通知类 bean 的 id

　　　　　　<aop:pointcut>：用于配置切入点表达式

　　　　　　　　属性：

　　　　　　　　　　expression：用于定义切入点表达式

　　　　　　　　　　id：用于给切入点表达式提供一个唯一标识

　　　　　　<aop:before>：用于配置前置通知

　　　　　　　　属性：

　　　　　　　　　　method：指定通知中方法的名称

　　　　　　　　　　pointcut：定义切入点表达式