1.spring是什么?
stuuts是web框架(jsp、zactionactionfrom)
hibernate是orm框架,处于持久层。
spring是容器框架,用于配置bean,并维护bean之间关系的框架
spring中有一个非常概念:bean是java中任何一种对象javabean、service、action,数据源,dao,ioc(控制反转inverse of control),di(dependency injection 依赖注入)
快速入门:
1.引入spring的开发包
2.创建spring的核心文件。applicationContext.xml该文件一般放在src目录下
3.在applicationContext.xml中配置bean
<?xml version="1.0" encoding="UTF-8"?>
<!--
- Middle tier application context definition for the image database.
-->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<!-- 在容器文件中配置bean -->
<!-- bean元素作用 当我们spring框架加载时,spring就会自动创建一个bean -->
<bean id="userService" class="com.service.UserService">
<!-- 这里就是注入 -->
<property name="name">
<value>biaobiao</value>
</property>
</bean>
</beans>
4.在Test.java中使用
//1.得到spring容器的applicationContext对象(容器对象)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService us = (UserService) ac.getBean("userService");
us.sayHello();
上面的功能等同于
UserService us = new UserService();
us.setName("biaobiao");
us.sayHello();
UserService.java
package com.service;
public class UserService {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void sayHello(){
System.out.println("hello world " + name);
}
}
5.细节讨论
传统方法和使用spring方法
5.1 使用spring没有new对象,我们把创建对象那个的任务交给spring框架。
当ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
执行的时候,我们的spring容器对象被创建,同时,applicationContext.xml中配置的bean就会被创建。
spring运行原理:
spring实际上是一个容器框架,可以配置各种bean,并且可以维护bean与bean的关系,我们需要使用某个bean的时候,我们可以getBean(id)使用即可。
IOC是什么:
ioc (inverse of controll)控制反转,控制反转就是把创建对象(bean),和维护对象(bean)的关系的权利从程序中转移到spring的容器中(applicationContext.xml),而程序本身不再维护。
DI是什么:
di(dependency injection)依赖注入:实际上di和ioc是同一个概念,spring设计者认为di更准确表示spring核心技术。
学习框架最重要的就是学习各个配置。
把ApplicationContext做成一个单例。
使用BeanFactory获取bean:
//使用beanfactory获取bean
BeanFactory bf = new XmlBeanFactory(new ClassPathResource("com/test/Beans.xml"));
我们使用beanfactory去获取bean,当实例化该容器的时候,该容器的bean不被实例化,只有当你去使用getBean某个bean时,才会实时的创建。好处就是节约内存,缺点就是速度比较慢。
(使用这句时ChangUpper cu = (ChangUpper) bf.getBean("ChangUpper");
才会被实例化。)
使用ApplicationContext获取bean
而使用ApplicationContext时,只要ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
这一句时bean就会被实例化。不管理用不用都被会实例化,好处就是可以预先加载,缺点就是耗费内存。
一般没有特殊要求,应当使用ApplicationContext完成。(90%)
bean scope:
singliton:单例,默认值(每次获取都都是同一个),在每个Spring IoC容器中一个bean定义对应一个对象实例。
prototype:原型(每次获取的都不是同一个),一个bean定义对应多个对象实例。
request:在一次HTTP请求中,一个bean定义对应一个实例;即每次HTTP请求将会有各自的bean实例, 它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。
session:在一个HTTP Session中,一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
global-session:在一个全局的HTTP Session中,一个bean定义对应一个实例。典型情况下,仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。
三种获取ApplicationContext应用的三种方法:
- ClassPathXmlApplicationContext--->通过类路径来获取
ApplicationContext ac = new ClassPathXmlApplicationContext("com/test/Beans.xml");
- FileSystemXmlApplicationContext--->通过文件路径
ApplicationContext ac = new FileSystemXmlApplicationContext("F:\\java\\work_1\\spring\\src\\com\\test\\Beans.xml");
- XmlWebApplicationContext
3.bean的生命周期:
- 实例化(当我们加载beans.xml文件是),把我们的bean(前提是scope=singleton)实例化到内存。
- 调用set()方法设置属性。
- 如果实现了bean名字关注接口(BeanNameAware),则可以通过调用setBeanName方法获取id。
- 如果你实现了bean工厂关注接口,则可以获取BeanFactory。
- 如果你是实现了ApplicationContextAware则调用方法
public void setAplicationContext(ApplicationContext arg0) throws BeansException{
.......
}
- 如果bean和一个后置处理器关联,则会自动调用Object postProcessBeforeInitialization方法。
- 如果实现了InitializingBean接口,则会调用afterPropertiesSet方法
- 如果自己在则可以在bean中定义自己的初始化方法。
- 如果bean和一个后置处理器关联,则会自动调用Object postProcessAfterInitialization方法。
- 使用我们的Bean。
- 容器关闭。
- 可通过实现DisposableBean接口来调用destory方法。
- 可以在调用定制的销毁方法。
小结:我们实际开发中往往没有这么多过程。常见的是:
1-->2-->6-->9-->10-->11
通过BeanFactory来获取bean对象,bean的生命周期是否和ApplicationContext一样。
答:不一样,1-->2-->-->3-->7-->8-->10-->11-->12--13.
4.配置bean
如何给集合类型注入值。
//Student.java
package com.student;
public class Student {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//Major.java
package com.student;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Major {
private String name;
private List<Student> studentList;
private Set<Student> studentSet;
private Map<String, Student> studentMap;
public Set<Student> getStudentSet() {
return studentSet;
}
public void setStudentSet(Set<Student> studentSet) {
this.studentSet = studentSet;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Student> getStudentList() {
return studentList;
}
public void setStudentList(List<Student> studentList) {
this.studentList = studentList;
}
public Map<String, Student> getStudentMap() {
return studentMap;
}
public void setStudentMap(Map<String, Student> studentMap) {
this.studentMap = studentMap;
}
}
//Bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
- Middle tier application context definition for the image database.
-->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
<bean id="student_1" class="com.student.Student">
<property name="name">
<value>王二小</value>
</property>
<property name="age">
<value>23</value>
</property>
</bean>
<bean id="student_2" class="com.student.Student">
<property name="name">
<value>张三丰</value>
</property>
<property name="age">
<value>43</value>
</property>
</bean>
<!-- List list中可以有相同的对象 -->
<bean id="majorList" class="com.student.Major">
<property name="name">
<value>数学系</value>
</property>
<property name="studentList">
<list>
<ref bean="student_1"/>
<ref bean="student_2"/>
</list>
</property>
</bean>
<!-- Set set中不能有相同的对象-->
<bean id="majorSet" class="com.student.Major">
<property name="name">
<value>中文系</value>
</property>
<property name="studentSet">
<set>
<ref bean="student_1"/>
<ref bean="student_2"/>
</set>
</property>
</bean>
<!-- Map -->
<bean id="majorMap" class="com.student.Major">
<property name="name">
<value>英文系</value>
</property>
<property name="studentMap">
<map>
<entry key="2001" value-ref="student_1"/>
<entry key="2002" value-ref="student_2"/>
</map>
</property>
</bean>
</beans>
//Main测试函数
package com.student;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext ac = new ClassPathXmlApplicationContext("com/student/Beans.xml");
System.out.println("*************通过List取值**********");
Major maList = (Major) ac.getBean("majorList");
System.out.println("专业:" + maList.getName());
for(Student stu: maList.getStudentList()){
System.out.println(stu.getName()+ " " + stu.getAge());
}
System.out.println("*************通过set取值**********");
Major maSet = (Major) ac.getBean("majorSet");
System.out.println("专业:" + maSet.getName());
for(Student stu: maSet.getStudentSet()){
System.out.println(stu.getName()+ " " + stu.getAge());
}
System.out.println("*************通过Map取值**********");
Major maMap = (Major) ac.getBean("majorMap");
System.out.println("专业:" + maMap.getName());
//迭代Map
//1.迭代器
Map<String, Student> stumap = maMap.getStudentMap();
Iterator it = stumap.keySet().iterator();
while(it.hasNext()){
String key = (String)it.next();
Student student = stumap.get(key);
System.out.println(key + " " + student.getName() + " " + student.getAge());
}
//2.Entry
for(Entry<String, Student> enMap:maMap.getStudentMap().entrySet() ){
System.out.println(enMap.getKey() + " " +enMap.getValue().getName()+" " + enMap.getValue().getAge());
}
}
}
内部bean使用方法:
<bean id="foo" class=".....Foo>
<property name=" 属性">
<!--第一种方法引用-->
<ref bean="bean对象名">
<!--内部bean-->
<bean>
<property>
</property>
</bean>
</property>
</bean>
继承表示:
<bean id="foo" parent="父类对象名" class=".....Foo>
<property name=" 属性" value="值"/>
</bean>
5.通过构造函数注入值
public class ExampleBean {
private int years;
private String ultimateAnswer;
public ExampleBean(int years, String ultimateAnswer) {
this.years = years;
this.ultimateAnswer = ultimateAnswer;
}
}
方法1.构造参数类型匹配
<bean id="exampleBean" class="examples.ExampleBean">
<constructor-arg type="int" value="7500000"/>
<constructor-arg type="java.lang.String" value="42"/>
</bean>
方法2.构造参数索引(通过使用索引属性不但可以解决多个简单属性的混淆问题,还可以解决有可能有相同类型的2个构造参数的混淆问题了,注意index是从0开始。
)
<bean id="exampleBean" class="examples.ExampleBean">
<constructor-arg index="0" value="7500000"/>
<constructor-arg index="1" value="42"/>
</bean>
6.自动装配
模式 | 说明 |
---|---|
no | |
byName | 根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean,并将其与属性自动装配。例如,在bean定义中将autowire设置为by name,而该bean包含master属性(同时提供setMaster(..)方法),Spring就会查找名为master的bean定义,并用它来装配给master属性。 |
byType | 如果容器中存在一个与指定属性类型相同的bean,那么将与该属性自动装配。如果存在多个该类型的bean,那么将会抛出异常,并指出不能使用byType方式进行自动装配。若没有找到相匹配的bean,则什么事都不发生,属性也不会被设置。如果你不希望这样,那么可以通过设置dependency-check="objects"让Spring抛出异常。 |
constructor | 与byType的方式类似,不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean,那么将会抛出异常。 |
autodetect | 通过bean类的自省机制(introspection)来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器,那么将使用byType方式。 |
//Dog.java get/set方法略
private String name;
private int age;
//Master.java
private String name;
private Dog dog;
- byname
<bean id="master" class="com.autowire.Master" autowire="byName">
<property name="name" value="朱元璋"></property>
</bean>
<bean id="dog" class="com.autowire.Dog">
<property name="name" value="小黄"/>
<property name="age" value="2"/>
</bean>
//测试
ApplicationContext ac = new ClassPathXmlApplicationContext("com/autowire/Beans.xml");
Master ma = (Master) ac.getBean("master");
System.out.println(ma.getName() + " " + ma.getDog().getName());
上面例子可以看出,并没有配置master中的dog属性,但是还是可以直接取出,这是因为配置了autowire="byName";
byType
和byName类似,没有配置master中dog属性,但是如果是 autowire="byType",那么spring回首先在配置中去加载property配置,如果没有dog属性,再回在beans中寻找Dog类型的bean,如果有多个,会抛异常。- constructor
其他和byName类似,但是在Master类中,必须有以Dog为参数的构造函数。
public Master(Dog dog) {
this.dog = dog;
}
4.autodetect
- defualt
- 这个需要在
当你在指定了default-autowrite后,所有的bean的默认的autowire就是指定的装配方法
如果没有在没有在这里指定,默认就是no。 - no
不自动装配
7. 启动注解
<context:annotation-config/>
该配置可以激活注解。
8.使用spring的特殊bean,完成分散配置。
//DBUtil.java
private String drivername;
private String url;
private String name;
private String password;
<!--Beans.xml-->
<!-- 引入db.properties-->
<context:property-placeholder location="classpath:com/properties/db.properties"/>
<bean id="dbutil" class="com.properties.DBUtil">
<property name="name" value="${name}"/>
<property name="drivername" value="${drivername}"/>
<property name="url" value="${url}"/>
<property name="password" value="${password}"/>
</bean>
db.properties
name=root
drivername=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost/conn
password=1234
8. aop编程
1.aop说明
aop(aspect oriented programming)面向切面编程,是对一类对象或者所有对象编程。
核心是在不增加代码的基础上还增加功能。
2.实例说明
目标,在调用TestService的sayHello()方法之前进行日志书写。
步骤:
1. 定义接口
public interface TestServiceInter {
public void sayHello();
}
2. 编写对象(被代理对象,即目标对象)
//set/get方法略
public class Test1Service implements TestServiceInter,TestServiceInter_2{
private String name;
@Override
public void sayHello() {
System.out.println("hello " + name);
}
}
3. 编写通知(前置通知:目标方法调用前调用)
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
/**
* paraMethod 调用的方法
* paramArrayOfObject:给她方法传递的参数
* paramObject:目标对象
*/
@Override
public void before(Method paramMethod, Object[] paramArrayOfObject, Object paramObject)
throws Throwable {
System.out.println("记录日志...." + paramMethod.getName());
}
}
4. 在beans.xml文件中配置
4.1 配置被代理对象
4.2 配置通知
4.3 配置代理对象,是ProxyFactoryBean的实例对象。
4.3.1 代理接口集
4.3.2 植入通知
4.3.3 配置被代理的对象
<!-- 配置被代理的对象 -->
<bean id="test1Service" class="com.aop.Test1Service">
<property name="name" value="朱元璋"></property>
</bean>
<!-- 配置前置通知 -->
<bean id="MyMethodBeforeAdvice" class="com.aop.MyMethodBeforeAdvice"></bean>
<!-- 配置代理对象 -->
<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 配置代理接口集 -->
<property name="proxyInterfaces">
<list>
<value>com.aop.TestServiceInter</value>
</list>
</property>
<!-- 把通知织入到代理对象 -->
<property name="interceptorNames">
<!-- 相当于把包MyMethodBeforeAdvice迁址通知和代理对象关联起来,我们
也可以把通知看成拦截器 -->
<value>MyMethodBeforeAdvice</value>
</property>
<!-- 配置被代理的对象,可以指定 -->
<property name="target" ref="test1Service"/>
</bean>
3.其他通知类型
通知类型 | 接口 | 描述 |
---|---|---|
Around | org.aopalliance.intercept.MethodInterceptor | 拦截对目标方法的调用 |
Before | Org.springframeword.aop.MethodBeforeAdvice | 在目标方法前调用 |
After | org.springframework.aop.AfterReturningAdvice | 在目标方法调用之后调用 |
Throws | Org.springframework.aop.ThrowAdvice | 在目标方法跑出异常时调用调用 |
(其他通知的使用方法和前置通知类似)
注:
环绕通知
public class MyMethodInterceptor implements MethodInterceptor {
/**
* @环绕通知
*/
@Override
public Object invoke(MethodInvocation paramMethodInvocation) throws Throwable {
System.out.println("环绕通知: 方法调用之前");
Object obj = paramMethodInvocation.proceed();//如果没有这句和返回切入的方法将不会被调用
System.out.println("环绕通知: 方法调用之后");
return obj;
}
}
异常通知
public class MyThrowAdvice implements ThrowsAdvice {
public void afterThrowing(Method m,Object[] os, Object targt,Exception e){
System.out.println("出事了~~ " + e.getMessage());
}
}
自定义通知切入点
<!-- 配置前置通知切入点(值让某个特定的方法切入前置通知) 只让sayHello方法切入前置通知-->
<bean id="MyMethodBeforeAdviceFilter" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
<property name="advice" ref="MyMethodBeforeAdvice"></property>
<property name="mappedNames">
<list>
<value>sayHello</value>
</list>
</property>
</bean>
在将MyMethodBeforeAdviceFilter织入到代理对象中就可以了。
所有配置总览表:
<!-- 配置被代理的对象 -->
<bean id="test1Service" class="com.aop.Test1Service">
<property name="name" value="朱元璋"></property>
</bean>
<!-- 配置前置通知 -->
<bean id="MyMethodBeforeAdvice" class="com.aop.MyMethodBeforeAdvice"></bean>
<!-- 配置后置通知 -->
<bean id="MyAfterReturningAdvice" class="com.aop.MyAfterReturningAdvice"></bean>
<!-- 配置环绕通知 -->
<bean id="MyMethodInterceptor" class="com.aop.MyMethodInterceptor"></bean>
<!-- 配置异常通知 -->
<bean id="MyThrowAdvice" class="com.aop.MyThrowAdvice"></bean>
<!-- 配置前置通知切入点(值让某个特定的方法切入前置通知) -->
<bean id="MyMethodBeforeAdviceFilter" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
<property name="advice" ref="MyMethodBeforeAdvice"></property>
<property name="mappedNames">
<list>
<value>sayHello</value>
</list>
</property>
</bean>
<!-- 配置代理对象 -->
<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 配置代理接口集 -->
<property name="proxyInterfaces">
<list>
<value>com.aop.TestServiceInter</value>
<value>com.aop.TestServiceInter_2</value>
</list>
</property>
<!-- 把通知织入到代理对象 -->
<property name="interceptorNames">
<!-- 相当于把包MyMethodBeforeAdvice迁址通知和代理对象关联起来,我们
也可以把通知看成拦截器 -->
<list>
<!-- 使用自定义前置通知的切入点 -->
<value>MyMethodBeforeAdviceFilter</value>
<!-- <value>MyMethodBeforeAdvice</value> -->
<value>MyAfterReturningAdvice</value>
<value>MyMethodInterceptor</value>
<value>MyThrowAdvice</value>
</list>
</property>
<!-- 配置被代理的对象,可以指定 -->
<property name="target" ref="test1Service"/>
</bean>
问:在spring的aop中,当你通过代理对象实现了接口aop接口的时候,获取的ProxyFactoryBean是什么类型?
答:返回的是一个代理对象,如果目标对象实现了接口,则spring使用jdk动态代理技术,如果目标对象没有实现接口, 则spring使用CGLIB技术。