java 学习笔记 关于spring2.5

Spring –SSH整合学习笔记

目录

第一课：面向抽象编程 (4)

第二课：Jdom的基本使用 (4)

第三课：模拟Spring功能 (5)

第四课：搭建sping的运行环境 (8)

一、建立一个新的项目 (8)

二、建立spring的配置文件 (8)

三、引入spring的jar包 (8)

四、测试代码： (8)

五、注意接口的使用： (8)

第五课：IOC(DI)配置及应用 (9)

一、什么是IOC、DI (9)

二、编辑xml文件时，没有提示 (9)

三、注入类型(Injecting dependencies) (9)

(一) setter注入类型Setter Injection (9)

(二) 构造方法Constructor Injection (10)

四、id、name (11)

五、简单属性的注入 (11)

六、Bean的作用范围scope (12)

七、集合注入 (12)

八、自动装配autowire (13)

(一) byName (13)

(二) byType (14)

(三) 注意 (14)

九、生命周期 (15)

(一) lazy-init/default-lazy-init (15)

(二) init-method destroy-method 不要和prototype一起用（了解） (15)

第六课：annotation方式Spring (16)

一、开始使用annotation配置Spring (16)

二、@Autowired、@Qualifier (16)

(一) @Autowired (16)

(二) @Qualifier (17)

三、@Resource(重要、推荐) (17)

(一) JSR-250 (17)

(二) @Resource (17)

四、@Componet (18)

五、@Scope、@PostConstruct、@PreDestroy (19)

六、注解对应的jar包 (19)

第七课：AOP(面向切面编程) (19)

一、AOP概念 (19)

二、利用动态代理实现面向切面编程 (20)

第八课：Spring AOP配置选项 (21)

一、AOP配置annotation方式 (21)

(一) 搭建annotation开发环境 (21)

(二) aspectJ类库 (22)

(三) AOP的annotation实例 (22)

(四) AspectJ的专业术语 (23)

(五) 织入点语法 (23)

(六) Advice (24)

(七) Pointcut (26)

(八) annotatin方式的AOP实例 (26)

二、AOP配置xml方式 (27)

三、AOP实现动态代理注意 (28)

第九课：DataSource (28)

一、Sping配置数据源： (28)

二、注入使用 (29)

三、dbcp.BasicDataSource (29)

第十课 Spring整合Hiberante3 (30)

一、Spring配置hibernate3的SessionFactory (30)

(一) xml形式的SessionFactory (30)

(二) annotation注解方式的SessionFactory (30)

二、引入hibernate所需要使用的jar (31)

(一) 基本jar (31)

(二) 加入annotation功能的jar包 (31)

(三) 搭建日志环境并配置显示DDL语句jar包 (31)

三、Spring整合hibernate3事务 (31)

(一) Annotation注解方式配置事务管理 (31)

(二) Spring事务选项 (35)

(三) XML文件形式配置Spring事务管理 (37)

四、HibernateTemplate (38)

(一) HibernateTemplate (38)

(二) HibernateDaoSupport (39)

第十一课：Spring整合-SSH (40)

一、第一步：加入jar包(需要的jar包列表) (40)

二、第二步：首先整合Spring + Hibernate (41)

三、第三步：再来整合Struts2 (41)

四、struts的读常量： (43)

第十二课：DTO、VO (43)

一、DTO (43)

二、VO (43)

第十二课：SSH整合存在的问题 (43)

一、Jsp中访问Session时，Session已经关闭 (43)

二、如果不配置事务，openSessionView出现异常 (44)

三、中文乱码问题： (44)

第十三课：SSH整合的jar包 (45)

一、Struts2 (45)

二、Hibernate3.3.2 (45)

三、Spring (46)

第一课：面向抽象编程

原来什么类都是写死的，现在是先建立一个大的标准，然后再各个实体类来实现他们的功能，然后在调用的时候，使用这个标准调用，这样，你们那个来都可以被调用。

实例：

User实体类

public class User {

private String username;

private String password;

public String getUsername() { return username; }

public void setUsername(String username) {https://www.doczj.com/doc/5213778734.html,ername = username;}

public String getPassword() {return password; }

public void setPassword(String password) {

this.password = password;

}}

UserDao接口

public interface UserDao {

public void save(User u);

}

UserDao的实现UserDaoImpl

public class UserDaoImpl implements UserDao {

@Override

public void save(User u) {

System.out.println("user save...");

}}

User管理类

public class UserService {

//这里需要什么的实现，在new时，就new什么的实现，在调用方法时，会调用具体的实现类的方法

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {return userDao;}

public void setUserDao(UserDao userDao) { https://www.doczj.com/doc/5213778734.html,erDao = userDao; }

public void add(User u){

userDao.save(u);}//这里可以调用任务实现了UserDao接口的save方法了。

}

第二课：Jdom的基本使用

test.xml

8G

200

1580

10G

500

3000

实例类：

public class Sample1 {

public static void main(String[] args) throws Exception{

SAXBuilder sb=new SAXBuilder();//创建一个SAXBuilder对象

Document doc=

sb.build(Sample1.class.getClassLoader().getResourceAsStream("test.xml"));

//构造文档对象

Element root=doc.getRootElement(); //获取根元素

List list=root.getChildren("disk");//取名字为disk的所有元素

for(int i=0;i

Element element=(Element)list.get(i);

String name=element.getAttributeValue("name");//获取元素中属性为name的值

String capacity=element.getChildText("capacity");//取disk子元素capacity的内容 String directories=element.getChildText("directories");

String files=element.getChildText("files");

System.out.println("磁盘信息:");

System.out.println("分区盘符:"+name);

System.out.println("分区容量:"+capacity);

System.out.println("目录数:"+directories);

System.out.println("文件数:"+files);

System.out.println("-----------------------------------");

} } }

第三课：模拟Spring功能

因为Spring是使用xml配置文件来实现的，所以我们首先模拟一个xml的配置文件如下：

beans.xml

实现的功能：当类初始化时，

一、程序会根据此配置文件初始化文件所有的bean元素所代表的类，放入一个容器中(使用Map)，然后在需要时，会根据ID

值，取出这个对象；

1、代码：

public class ClassPathXmlApplicationContext implements BeanFactory {

private Map beans = new HashMap();

public ClassPathXmlApplicationContext() throws Exception{

SAXBuilder sb=new SAXBuilder();//创建一个SAXBuilder对象

Document

doc=sb.build(ClassPathXmlApplicationContext.class.getClassLoader().getResourceAsStream("b eans.xml")); //构造文档对象

Element root=doc.getRootElement(); //获取根元素

//System.out.println(root.getName());

List list=root.getChildren("bean");//取名字为disk的所有元素

for(int i=0;i

Element element=(Element)list.get(i);

String id = element.getAttributeValue("id");

String clazz = element.getAttributeValue("class");

System.out.println(id + ":" + clazz);

Object o = Class.forName(clazz).newInstance();

beans.put(id, o);

}

}

public Object getBean(String name){

return beans.get(name);

}

}

2、测试：

BeanFactory factory = new ClassPathXmlApplicationContext();

UserService service = new UserService();

//UserService service = (UserService)factory.getBean("userService");

UserDao userDao = (UserDao)factory.getBean("u");//此得只需要根据ID就可以取得Bean对象来使用service.setUserDao(userDao);

User u = new User();

service.add(u);

二、当某一bean元素下存在property子元素时，则需要把这个子元素作为参数自动注入(使用setXXX方法)到这个bean对象中

1、代码：

public class ClassPathXmlApplicationContext implements BeanFactory {

private Map beans = new HashMap();

public ClassPathXmlApplicationContext() throws Exception{

SAXBuilder sb=new SAXBuilder();//创建一个SAXBuilder对象

Document

doc=sb.build(ClassPathXmlApplicationContext.class.getClassLoader().getResourceAsStream("bea ns.xml")); //构造文档对象

Element root=doc.getRootElement(); //获取根元素

List list=root.getChildren("bean");//取名字为disk的所有元素

for(int i=0;i

Element element=(Element)list.get(i);

String id = element.getAttributeValue("id");

String clazz = element.getAttributeValue("class");

System.out.println(id + ":" + clazz);

Object o = Class.forName(clazz).newInstance();

beans.put(id, o);

//* 以下for循环是实现模拟spring自动装配(注入)功能

//一开始列出此bean的所有property子元素

for (Element propertyElement : (List)element.getChildren("property")){

//获取property子元素中属性为name的值(也就是需要注入的参数名称)

String name = propertyElement.getAttributeValue("name");

//获取property子元素中属性为bean的值 (需要注入参数的类型),此处的bean值是已经在上面初始化好了的bean

的ID了。

String bean = propertyElement.getAttributeValue("bean");

//因此此处获取指定ID的bean

Object beanObject = beans.get(bean);

//组成set方法名称：set + 第一个字母大写 + 其它的字母

String methodName = "set" + name.substring(0,1).toUpperCase() + name.substring(1);

System.out.println("methodName = " + methodName);

//获取bean的set方法，参数(方法名，参数：此参数的类型)

Method m = o.getClass().getMethod(methodName,

beanObject.getClass().getInterfaces()[0]);

//使用反映机制，执行method方法，从而实现注入功能

m.invoke(o, beanObject);

}

}

}

public Object getBean(String name){

return beans.get(name);

}

}

注意，以上有背景色的部分是实现自动装配(注入)的代码。

2、测试

public void testAdd_3() throws Exception {

BeanFactory factory = new ClassPathXmlApplicationContext();

UserService service = (UserService)factory.getBean("userService");

//以下两行代码在实现注入功能后，将不再需要，因为程序在加载时，已经帮我自动注入这个参数了。

//UserDao userDao = (UserDao)factory.getBean("u");

//service.setUserDao(userDao);

User u = new User();

service.add(u);

}

BeanFactory接口代码：

public interface BeanFactory {

public Object getBean(String name);

}

第四课：搭建sping的运行环境

一、建立一个新的项目

a)建立新的项目；

b)建立需要的bean类

二、建立spring的配置文件

你可以在spring文件中复制代码

xmlns:xsi="https://www.doczj.com/doc/5213778734.html,/2001/XMLSchema-instance"

xsi:schemaLocation="https://www.doczj.com/doc/5213778734.html,/schema/beans

https://www.doczj.com/doc/5213778734.html,/schema/beans/spring-beans-2.5.xsd">

三、引入spring的jar包

可以建立一个User Library

搭建spring环境基本的包：spring.jar和commons-logging.jar

四、测试代码：

public void testAdd_3() throws Exception {

BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");

UserService service = (UserService)factory.getBean("userService");

User u = new User();

service.add(u);

}

注意：这里使用的ClassPathXmlApplicationContext和BeanFactory是spring的，如下：

import org.springframework.beans.factory.BeanFactory;

import org.springframework.context.support.ClassPathXmlApplicationContext;

五、注意接口的使用：

ClassPathXmlApplicationContext类实现了ApplicationContext接口，而ApplicationContext接口又实现了BeanFactory接口，这样BeanFactory是根上的接口。一般建议使用ApplicationContext接口，因为：

1、BeanFactory:只是完成Bean工厂的基本功能，不能完成bean的生命周期

2、ApplicationContext：除了完成bean工厂的基本功能外，还完成的其它的附加功能(比如：bean的生

命周期)，也就是功能更强大

这样上面的代码就是

public void testAdd_3() throws Exception {

ApplicationContext factory = new ClassPathXmlApplicationContext("beans.xml");

UserService service = (UserService)factory.getBean("userService");

User u = new User();

service.add(u);

}

第五课：IOC(DI)配置及应用

一、什么是IOC、DI

IOC:Inversion of Control控制反转：原来类的一些成员属性(例如UserService中的userDao成员属性)是由当前类(UserService)自己控制，现在不是由当前类(UserService)自己控制，而是由容器(运行环境上下文、Spring)帮我们来控制。

还是一种说法：原来我们自己控制是控制实现，而现在Spring是利用接口来控制的。所以我们由原来控制实现转为springg 现在来控制接口(向上反转)

作用：实例化具体的bean

动态装配bean

(本来是由我来控制的，现在我交给容器来控制。)

DI:Dependency Injection依赖注入：一些成员属性(例如UserService中的userDao成员属性) 依赖Spring容器来注入好处：偶合性相对来降低了；另外，注入是使用配置文件来实现，这样修改来非常的方便.

DI与IOC相对来说是一样的概念。

二、编辑xml文件时，没有提示

1、window – preferences – myeclipse – Files and Editing - xml – xml catalog

2、add按钮

i.Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\spring-beans-2.5.xsd

ii.URI: file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resources/spring-beans-2.5.xsd

iii.Key Type: Schema Location

iv.Key: https://www.doczj.com/doc/5213778734.html,/schema/beans/spring-beans-2.5.xsd

三、注入类型(Injecting d epend encies)

1、setter(重要)

2、构造方法(使用的非常少)

3、接口注入(可以忘记)

(一)setter注入类型Setter Injection

就是在bean中使用setXXX方法进行注入来

在bean类中，成员属性需要setXXX方法如下：

public class UserService {

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {

return userDao;

}

public void setUserDao(UserDao userDao) {

https://www.doczj.com/doc/5213778734.html,erDao = userDao;

}

public void add(User u){ userDao.save(u);}

}

spring配置文件如下：

(二)构造方法Constructor Injection

首先在bean类中需要有成员属性作为参数的构造方法

代码如下：

public class UserService {

private UserDao userDao = new UserDaoImpl();

public UserService(UserDao userDao) {

super();

https://www.doczj.com/doc/5213778734.html,erDao = userDao;

}

public UserDao getUserDao() {return userDao;}

public void setUserDao(UserDao userDao) { https://www.doczj.com/doc/5213778734.html,erDao = userDao;} public void add(User u){ userDao.save(u);}

}

注意：背景较深的代码为构造方法，带有参数的构造方法

spring配置文件如下：

使用和其子标签或进行构造方法注入

当构造方法注入时，构造方法中有多个参数时，可以使用以下两种方式注入：

bean代码：

public class ExampleBean {

private int years;

private String ultimateAnswer;

public ExampleBean(int years, String ultimateAnswer) {

this.years = years;

this.ultimateAnswer = ultimateAnswer;

}

}

1、参数类型方式进行区分参数：

xml配置文件：

注意：这样就是参数类型为int的注入7500000,而参数类型为https://www.doczj.com/doc/5213778734.html,ng.String的参数注入”42”,但这个方法不适合多个参数是相同的类型。

2、利用索引进行区分参数

xml配置文件

注意：index=0的注入到第一个参数，index=1的注入到第二个参数。

构造方法的注入不方便，所以我们需要使用setter注入方式。

四、id、name

注xml配置文件中标签中的属性名称如下：

或

以上标签中的属性id与name作用是一样，

唯一的区别：id中不可以含有特殊字符，而name中可以有特殊字符

五、简单属性的注入

当bean中存在简单属性时的注入方式：

bean代码如下：

public class UserDaoImpl implements UserDao {

private int daoId;

private String daoStatus;

public int getDaoId() {return daoId;}

public void setDaoId(int daoId) {this.daoId = daoId; }

public String getDaoStatus() { return daoStatus; }

public void setDaoStatus(String daoStatus) {this.daoStatus = daoStatus;}

@Override

public void save(User u) {System.out.println("user save...");}

}

xml配置文件如下：

good

直接使用 value属性或是子标签来注入

六、Bean的作用范围scope

在Spring配置文件中的标签可以指定bean的作用范围

利用标签中的scope属性来指定

scope值：

1、singleton单例：每次取出的bean都是同一个bean。默认就是这个

2、prototype原型：每次取的bean时，都会重新创建一个新的bean

3、request

4、session

5、globalsession

实例：

注意：只有spring与web框架结合时才会使用request/session/globalsession，但也非常少用，因为其它框架已经有功能非常强大的scope了(例如：struts的scope)

七、集合注入

很少用，不重要，参考程序

administrator@https://www.doczj.com/doc/5213778734.html,

support@https://www.doczj.com/doc/5213778734.html,

development@https://www.doczj.com/doc/5213778734.html,

a list element followed by a reference

an entry

just some string

a ref

just some string

八、自动装配autowire

含义：在bean注入时不需要我们来指定注入哪个具体的bean，而spring容器会根据我的使用autowire属性来确定自动装配功能。

autowire值：

1、autodetect;

2、byName:根据bean中成员属性的名称来自动装配

3、byType：根据bean中成员属性的类型来自动装配。

4、constaractor

5、default：会根据标签中的default-autowire属性来进行自动装配的方式

6、no(默认就是这个，需要手动指定注入那个bean)

(一)byName

根据bean中成员属性的名称来自动装配。

bean代码：

UserDaoImpl类

public class UserDaoImpl implements UserDao {

private int daoId;

public int getDaoId() {return daoId;}

public void setDaoId(int daoId) {this.daoId = daoId; }

@Override

public String toString(){

return"daoId=" + this.daoId;

}}

UserService类

public class UserService {

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {

return userDao;

}

public void setUserDao(UserDao userDao) {

https://www.doczj.com/doc/5213778734.html,erDao = userDao;

}

public void add(User u){

userDao.save(u);

}}

spring的配置文件

测试代码：

public void testAdd_4() throws Exception {

ApplicationContext factory = new ClassPathXmlApplicationContext("beans.xml");

UserService service = (UserService)factory.getBean("userService");

System.out.println(service.getUserDao());

}

结果：daoId=1

说明：因为在配置文件中配置了两个UserDaoImpl(名称分别：userDao、userDao2)和一个UserService类。而在userService的bean中并没有进行注入配置。而是使用了autowire属性指定了byName值，这样结果是正确的，是因为spring看到autowire=byName后，会在配置文件中查找bean的id与userService成员属性名称一至，然后将其注入，这样就完成了根据名称自动装配功能。

(二)byType

根据类型自动装配：就是spring在初始化时，会在配置文件中查找的类型与userService成员属性的类型相比较，类型一致的将其注入，这样就完成了根据类型自动装配。

(三)注意

1、自动装配使用并不多；

2、只有在使用anntation注解时会使用的。

3、byType如果出现相同类型在两个以上，就会出现异常。

九、生命周期

(一)lazy-init/default-lazy-init

(不重要)

bean的何时初始化

lazy-init值：default：表示使用标签中的default-lazy-init值

true:表示context在初始化时，不会初始化这个bean，只有在使用时才会初始化

false：表示context在初始化时，就会初始化这个bean

例如：

xmlns:xsi="https://www.doczj.com/doc/5213778734.html,/2001/XMLSchema-instance"

xsi:schemaLocation="https://www.doczj.com/doc/5213778734.html,/schema/beans

https://www.doczj.com/doc/5213778734.html,/schema/beans/spring-beans-2.5.xsd"

default-lazy-init="false">

(二)init-method destroy-method 不要和prototype一起用（了解）

init-method：用于标签中的属性，表示在初始化这个bean之前所需要的执行方法

destroy-method:用于标签中的属性，表示在这个bean销毁时所需要的执行方法。例如关闭连接池。

注意：此属性不要与scpoe=”prototype”一起使用，否则会出现其它的问题。

例如：

userService类的代码

public class UserService {

public void init(){

System.out.println("现在开始初始化UserService");

}

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {return userDao; }

public void setUserDao(UserDao userDao) {https://www.doczj.com/doc/5213778734.html,erDao = userDao;}

public void add(User u){ userDao.save(u);}

public void destroy(){System.out.println("destory"); }

}

测试代码：

public void testAdd_4() throws Exception {

ClassPathXmlApplicationContext factory = new

ClassPathXmlApplicationContext("beans.xml");

UserService service = (UserService)factory.getBean("userService");

System.out.println(service.getUserDao());

//因为在非webApplacationContext中不能自动destory，因为需要手动destory

//而ApplicationContext没有实现destory方法，因此需要具体的实现类来destory

factory.destroy();

}

第六课：annotation方式Spring

一、开始使用annotation配置Spring

首先需要在spring的xml配置文件中加入下列红色加粗部分的代码。

xmlns:xsi="https://www.doczj.com/doc/5213778734.html,/2001/XMLSchema-instance"

xmlns:context="https://www.doczj.com/doc/5213778734.html,/schema/context"

xsi:schemaLocation="https://www.doczj.com/doc/5213778734.html,/schema/beans

https://www.doczj.com/doc/5213778734.html,/schema/beans/spring-beans-2.5.xsd

https://www.doczj.com/doc/5213778734.html,/schema/context

https://www.doczj.com/doc/5213778734.html,/schema/context/spring-context-2.5.xsd">

这样当spring加载配置文件时，发现有标签后，会帮我加载以下四个类（用于处理annotation方式的配置）：

1、AutowiredAnnotationBeanPostProcessor,

2、CommonAnnotationBeanPostProcessor,

3、PersistenceAnnotationBeanPostProcessor,

4、RequiredAnnotationBeanPostProcessor

二、@Autowired、@Qualifier

还是需要在xml文件中配置bean

(一)@Autowired

位置：可以放在成员属性前面，也可以放在getter或setter方法前面，但是建议放在setter方法前面

作用：表示该对应的成员属性可以完成自动配置功能(默认是根据byType的)

例如：

xmp配置文件：

前缀部分见上面代码，以此略。。。

userService

public class UserService {

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {return userDao;}

//表示该成员属性可以自动装配(默认根据类型byType)

//annotation建议放在setter方法前面

@Autowired

public void setUserDao(UserDao userDao) {

https://www.doczj.com/doc/5213778734.html,erDao = userDao;

}

public void add(User u){

userDao.save(u);

}}

说明：这样spring就可以帮我们完成自动装配功能(默认是根据byType)

(二)@Qualifier

因为@Autowired默认是根据byType来自动装配注入的。当有多个相同类型的bean时，Spring就会出现异常，提示找到多个符合条件的bean，但是不知道选择哪个bean来注入。

这时我们需要另外一注解来告诉Spring用那个bean，这就是@Qualifier注解,@Qualifier使用value参数来指定注入那个bean

代码：

public class UserService {

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {return userDao;

}

//表示该成员属性可以自动装配(默认根据类型byType)

//当配置文件中有多个相同类型的bean时，需要使用@Qualifier注解来说明那个bean来自动装配

@Autowired

public void setUserDao(@Qualifier(value="u") UserDao userDao) {

https://www.doczj.com/doc/5213778734.html,erDao = userDao;

}

public void add(User u){ userDao.save(u);}

}

三、@Resource(重要、推荐)

还是需要在xml文件中配置bean

(一)JSR-250

JCP:Java Community Process是由多个厂家出人来构成的J2EE组织，主要是用于定Java的一些新的标准而每一个标签都可以称之为一个JSR

而每一个新的JSR都会加一个数字是区别什么JSR，可以到官方网看看具体JSR定了哪些新的标准。(二)@Resource

代码：

import javax.annotation.Resource;

public class UserService {

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {

return userDao;

}

//在这里引用了一个资源，这个资源的名称和这个setter方法后面的成员属性名称一致(userDao)

//注意这个@Resource是J2EE的(import javax.annotation.Resource)

@Resource

public void setUserDao(UserDao userDao) {

https://www.doczj.com/doc/5213778734.html,erDao = userDao;

}

public void add(User u){userDao.save(u);}

}

说明：在这里引用了一个资源，这个资源的名称和这个setter方法后面的成员属性名称一致(userDao)

注意这个@Resource是J2EE的(import javax.annotation.Resource)

@Resource默认是根据byName来的，如果没有找到相同的名称再根据byTyp e，当然也可以指定bean的name如下：@Resource(name="u2")

public void setUserDao(UserDao userDao) {

https://www.doczj.com/doc/5213778734.html,erDao = userDao;

}

注意：一般使用@Resource而不会使用@Autowired

不足：如果没有源码，就无法使用annotation，只能使用xml

四、@Componet

以上使用@Autowired、@Resource注解时，还是需要在xml文件配置bean，这样就达不到完全使用annotation进行注解。因此现在引用@Component在那个bean前进行注解，表示那个类是需要的bean

有了@Componet注解，这样就不需要在xml文件中配置bean了。

注意：@Componet是Spring的注解(https://www.doczj.com/doc/5213778734.html,ponent;)

例如：

前缀部分见上面代码，以此略。。。

bean类中需要使用@Componet（或@Service、@Repository、@Controller）注解这个类是bean。

代码：

import javax.annotation.Resource;

import https://www.doczj.com/doc/5213778734.html,ponent;

// @Componet注解默认bean的名称是类名首字母小写

// 也可以利用value属性指定bean的名称

@Component(value="userService")

public class UserService {

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {return userDao;}

//在这里引用了一个资源，这个资源的名称和这个setter方法后面的成员属性名称一致(userDao)

//注意这个@Resource是J2EE的(import javax.annotation.Resource)

@Resource

public void setUserDao(UserDao userDao) {https://www.doczj.com/doc/5213778734.html,erDao = userDao;}

public void add(User u){userDao.save(u);}}

注意：@Componet注解，默认bean的名称是类的首字母小写，当然也可以利用value属性指定bean名称（在annotation中属性为

value可以不写，直接写值）

一般建议@Componet注解后面都指定名称。

说明：当Spring在加载配置文件时，发现有标签，并且后面的base-package属性指定了包名，就会在这个指定的包名下面搜索灰，看哪个类用@Componet进行了注解，如果有Spring就将其初始化到容器中，认为是一个bean

五、@Scope、@PostConstruct、@PreDestroy

@Scope对应于xml配置文件的scope属性

@PostConstruct对应于xml配置文件中的init-method属性

@PreDestroy对于应于xml配置文件中的destroy-method属性

例如如下：

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.annotation.Resource;

import org.springframework.context.annotation.Scope;

import https://www.doczj.com/doc/5213778734.html,ponent;

@Component(value="userService")

@Scope("singleton")

public class UserService {

@PostConstruct

public void init(){System.out.println("现在开始初始化UserService");}

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {return userDao;}

@Resource

public void setUserDao(UserDao userDao) {https://www.doczj.com/doc/5213778734.html,erDao = userDao;}

public void add(User u){ userDao.save(u);}

@PreDestroy

public void destroy(){System.out.println("destory"); }

六、注解对应的jar包

1、@Autowired org.springframework.beans.factory.annotation.Autowired;

2、@Qualifier org.springframework.beans.factory.annotation.Qualifier;

3、@Componet https://www.doczj.com/doc/5213778734.html,ponent;

4、@Resource javax.annotation.Resource;

5、@Scope org.springframework.context.annotation.Scope;

6、@PostConstruct javax.annotation.PreDestroy;

7、@PreDestroy javax.annotation.PreDestroy;

第七课：AOP(面向切面编程)

一、AOP概念

AOP：Aspect Oriented Programming(面向切面编程)

是对面向对象的思维方式的有国补充

二、利用动态代理实现面向切面编程

场景：需要在执行方法之前加入一些日志。。。

可以使用以下三种方法

1、继承

2、组合

3、动态代理(我们的实例)

UserDao接口

public interface UserDao {

public void save(User u);

public void delete(User u);

}

UserDaoImpl(UserDao接口的现实)

public class UserDaoImpl implements UserDao {

@Override

public void save(User u) {System.out.println("user save...");}

@Override

public void delete(User u) {System.out.println("user delete...");}

}

UserService(业务层)

public class UserService {

private UserDao userDao = new UserDaoImpl();

public UserDao getUserDao() {return userDao;}

public void setUserDao(UserDao userDao) {https://www.doczj.com/doc/5213778734.html,erDao = userDao;} public void add(User u){ userDao.save(u);}

public void delete(User u){ userDao.delete(u);}

}

User(实体对象)

public class User {

private String username;

private String password;

public String getUsername() {return username; }

public void setUsername(String username) {https://www.doczj.com/doc/5213778734.html,ername = username;} public String getPassword() {return password; }

public void setPassword(String password) {this.password = password;} }

Spring的配置文件