1、什么是Spring
Spring是一个开源框架，为了解决企业应用开发的复杂性而创建的，主要优势之一就是其分层架构，它的核心是控制反转（IOC）和面向切面（AOP），简单来说，Spring是一个分层的JavaSE/EEfull-stack（一站式）轻量级开源框架。
2、Spring的优点
1、方便解耦，简化开发
Spring就是一个大工厂，可以将所有对象创建和依赖关系维护交给Spring管理。
2、AOP编程的支持（所谓AOP就是功能抽取）
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
3、声明事务的支持
只需要通过配置就可以完成对事务的管理，而无需手动编程。
4、方便程序的测试
Spring对Junit4支持，可以通过注解方便的测试Spring程序。
5、方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持。
6、降低JavaEE API的使用难度
Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低。
3、Spring搭建
4、属性注入
代码示例
Car.java
package cn.ctgu.bean;
public class Car {
private String name;
private String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Car [name=" + name + ", color=" + color + "]";
}
}User.java
package cn.ctgu.bean;
public class User {
private String name;
private Integer age;
private Car car;
public User() {
System.out.println("User对象空参构造方法！");
// TODO Auto-generated constructor stub
}
public User(String name, Car car) {
System.out.println("User(String name,Car car)!!");
this.name = name;
this.car = car;
}
public User(Car car, String name) {
System.out.println("User(String name,Car car)!!");
this.name = name;
this.car = car;
}
public User(Integer name, Car car) {
System.out.println("User(String name,Car car)!!");
this.name = name+"";
this.car = car;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public void init() {
System.out.println("我是初始化方法！");
}
public void destroy() {
System.out.println("我是销毁方法！");
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
}
}CollectionBean.java
package cn.ctgu.injection;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
public class CollectionBean {
private Object[]arr;//数组类型注入
private List list;//list/set类型注入
private Map map;//map类型注入
private Properties prop;//Properties类型注入
public Object[] getArr() {
return arr;
}
public void setArr(Object[] arr) {
this.arr = arr;
}
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
public Map getMap() {
return map;
}
public void setMap(Map map) {
this.map = map;
}
public Properties getProp() {
return prop;
}
public void setProp(Properties prop) {
this.prop = prop;
}
@Override
public String toString() {
return "CollectionBean [arr=" + Arrays.toString(arr) + ", list=" + list + ", map=" + map + ", prop=" + prop
+ "]";
}
}
配置文件applicationContext.xml，在cn.ctgu.bean下（主要是set方式属性注入）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
<!--set方式属性注入： -->
<bean name="user" class="cn.ctgu.bean.User">
<!-- 值类型注入：为User对象中名为name的属性注入tom作为值 -->
<property name="name" value="tom"></property>
<property name="age" value="18"></property>
<!-- 引用类型注入：为car属性注入下方配置的car对象 -->
<property name="car" ref="car"></property>
</bean>
<!-- 将car对象配置到容器中 -->
<bean name="car" class="cn.ctgu.bean.Car">
<property name="name" value="兰博基尼"></property>
<property name="color" value="黄色"></property>
</bean>
<bean name="cb" class="cn.ctgu.injection.CollectionBean">
<!-- 如果数组中只准备注入一个值（对象），直接使用value或ref即可 -->
<property name="arr" value="tom"></property>
</bean>
</beans>
配置文件applicationContext.xml（构造函数注入、集合注入），在cn.ctgu.injection下
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
<!--set方式属性注入： -->
<bean name="user" class="cn.ctgu.bean.User">
<!-- 值类型注入：为User对象中名为name的属性注入tom作为值 -->
<property name="name" value="tom"></property>
<property name="age" value="18"></property>
<!--引用类型注入：为car属性注入下方配置的car对象 -->
<property name="car" ref="car"></property>
</bean>
<!-- 将car对象配置到容器中 -->
<bean name="car" class="cn.ctgu.bean.Car">
<property name="name" value="兰博基尼"></property>
<property name="color" value="黄色"></property>
</bean>
<!--====================================================-->
<!-- 构造函数注入 -->
<bean name="user2" class="cn.ctgu.bean.User">
<!-- name属性：构造函数的参数名
index属性：构造函数的参数索引
type属性：构造函数的参数类型
-->
<constructor-arg name="name" index="0" type="java.lang.Integer" value="999"></constructor-arg>
<constructor-arg name="car" ref="car" index="1"></constructor-arg>
</bean>
<!--===============数组注入====================== -->
<bean name="cb" class="cn.ctgu.injection.CollectionBean">
<!-- 如果数组中只准备注入一个值（对象），直接使用value或ref即可 -->
<property name="arr" value="tom"></property>
</bean>
<!--================数组注入多个元素===================== -->
<bean name="cd" class="cn.ctgu.injection.CollectionBean">
<!-- 如果数组中只准备注入一个值（对象），直接使用value或ref即可 -->
<property name="arr" >
<array>
<value>tom</value>
<value>jerry</value>
<ref bean="user2"/>
</array>
</property>
</bean>
<!--================list注入===================== -->
<bean name="list1" class="cn.ctgu.injection.CollectionBean">
<property name="list" value="jack"></property>
</bean>
<!--================列表注入多个元素===================== -->
<bean name="list2" class="cn.ctgu.injection.CollectionBean">
<!-- 如果数组中只准备注入一个值（对象），直接使用value或ref即可 -->
<property name="list" >
<list>
<value>tom</value>
<value>jerry</value>
<ref bean="user2"/> <!-- 对象 -->
</list>
</property>
</bean>
<!--================map注入===================== -->
<bean name="map" class="cn.ctgu.injection.CollectionBean">
<property name="map">
<map>
<entry key="url" value="jdbc://"></entry>
<entry key="user2" value-ref="user2"></entry><!--键为字符串，值为对象 -->
<entry key-ref="user2" value-ref="user2"></entry><!-- 键为对象，值为对象 -->
</map>
</property>
</bean>
<!--================properties注入===================== -->
<bean name="prop" class="cn.ctgu.injection.CollectionBean">
<property name="prop">
<props>
<prop key="dirverClass">com.jdbc</prop>
<prop key="userName">root</prop>
<prop key="password">1234</prop>
</props>
</property>
</bean>
</beans>
测试类Demo.java（以上几种注入方式的测试类）
package cn.ctgu.injection;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.ctgu.bean.User;
public class Demo {
//set方式属性注入
@Test
public void fun1() {
//1、创建容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("cn/ctgu/injection/applicationContext.xml");
//2、向容器"要"user对象
User u=(User)ac.getBean("user");
//3、打印user对象
System.out.println(u);
}
//构造函数注入
@Test
public void fun2() {
//1、创建容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("cn/ctgu/injection/applicationContext.xml");
//2、向容器"要"user对象
User u=(User)ac.getBean("user2");
//3、打印user对象
System.out.println(u);
}
@Test
public void fun3() {
//1、创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/ctgu/injection/applicationContext.xml");
//2、向容器"要"user对象
CollectionBean cb = (CollectionBean) ac.getBean("cb");
//3、打印user对象
System.out.println(cb);
}
@Test
public void fun4() {
//1、创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/ctgu/injection/applicationContext.xml");
//2、向容器"要"user对象
CollectionBean cd = (CollectionBean) ac.getBean("cd");
//3、打印user对象
System.out.println(cd);
}
@Test
public void fun5() {
//1、创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/ctgu/injection/applicationContext.xml");
//2、向容器"要"user对象
CollectionBean list1 = (CollectionBean) ac.getBean("list1");
//3、打印user对象
System.out.println(list1);
}
@Test
public void fun6() {
//1、创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/ctgu/injection/applicationContext.xml");
//2、向容器"要"user对象
CollectionBean list2 = (CollectionBean) ac.getBean("list2");
//3、打印user对象
System.out.println(list2);
}
@Test
public void fun7() {
//1、创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/ctgu/injection/applicationContext.xml");
//2、向容器"要"user对象
CollectionBean map = (CollectionBean) ac.getBean("map");
//3、打印user对象
System.out.println(map);
}
@Test
public void fun8() {
//1、创建容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("cn/ctgu/injection/applicationContext.xml");
//2、向容器"要"user对象
CollectionBean prop = (CollectionBean) ac.getBean("prop");
//3、打印user对象
System.out.println(prop);
}
}5、创建对象
代码示例
cn.ctgu.bean下的User.java
package cn.ctgu.bean;
public class User {
private String name;
private Integer age;
private Car car;
public User() {
System.out.println("User对象空参构造方法！");
// TODO Auto-generated constructor stub
}
public User(String name, Car car) {
System.out.println("User(String name,Car car)!!");
this.name = name;
this.car = car;
}
public User(Car car, String name) {
System.out.println("User(String name,Car car)!!");
this.name = name;
this.car = car;
}
public User(Integer name, Car car) {
System.out.println("User(String name,Car car)!!");
this.name = name+"";
this.car = car;
}
public Car getCar() {
return car;
}
public void setCar(Car car) {
this.car = car;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public void init() {
System.out.println("我是初始化方法！");
}
public void destroy() {
System.out.println("我是销毁方法！");
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
}
}
cn.ctgu.test下的UserFactory.java
package cn.ctgu.test;
import cn.ctgu.bean.User;
public class UserFactory {
public static User createUser() {
System.out.println("静态工厂创建User");
return new User();
}
public User createUser2() {
System.out.println("实例工厂创建User");
return new User();
}
}配置文件applicationContext.xml（cn.ctgu.create下）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
<!--创建方式1：空参构造创建对象 -->
<!--
scope:singleton（默认值） 单例模式,被标识为单例的对象在spring容器中只会存在一个实例
scope:prototype 多例模式,被标识为多例的对象,每次再获得才会创建，每次创建都是新的对象
init-method属性：配置一个方法作为生命周期初始化方法，spring会在对象创建之后立即调用
destroy-method属性： 配置一个方法作为生命周期的销毁方法，spring容器在关闭并销毁所有容器中的对象之前调用
-->
<bean name="user" class="cn.ctgu.bean.User" scope="singleton" init-method="init" destroy-method="destroy"></bean>
<!-- 创建方式2:静态工厂创建 对象
调用UserFactory的createUser方法创建名为user2的对象，放入容器
-->
<bean name="user2"
class="cn.ctgu.test.UserFactory"
factory-method="createUser"
></bean>
<!-- 创建方式3:实例工厂创建 对象
调用UserFactory的createUser2方法创建名为user3的对象，放入容器
-->
<bean name="user3"
factory-bean="userFactory"
factory-method="createUser2"></bean>
<bean name="userFactory"
class="cn.ctgu.test.UserFactory"></bean>
<!-- 导入其他spring配置文件 -->
<import resource="cn/ctgu/create/applicationContext.xml"/>
</beans>测试类Demo.java
package cn.ctgu.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.ctgu.bean.User;
public class Demo {
//创建对象方式一：空参构造创建
@Test
public void fun1() {
//1、创建容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("cn/ctgu/create/applicationContext.xml");
//2、向容器"要"user对象
User u=(User)ac.getBean("user");
//3、打印user对象
System.out.println(u);
}
//创建对象方式二：静态工厂创建对象
@Test
public void fun2() {
//1、创建容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("cn/ctgu/create/applicationContext.xml");
//2、向容器"要"user对象
User u=(User)ac.getBean("user2");
//3、打印user对象
System.out.println(u);
}
//创建对象方式三：实例工厂
@Test
public void fun3() {
//1、创建容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("cn/ctgu/create/applicationContext.xml");
//2、向容器"要"user对象
User u=(User)ac.getBean("user3");
//3、打印user对象
System.out.println(u);
}
//scope:singleton（默认值） 单例模式,被标识为单例的对象在spring容器中只会存在一个实例
//scope:prototype 多例模式,被标识为多例的对象,每次再获得才会创建，每次创建都是新的对象
@Test
public void fun4() {
//1、创建容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("cn/ctgu/create/applicationContext.xml");
//2、向容器"要"user对象
User u=(User)ac.getBean("user");
User u2=(User)ac.getBean("user");
User u3=(User)ac.getBean("user");
User u4=(User)ac.getBean("user");
System.out.println(u2==u4);//单例：true 多例：false
//3、打印user对象
System.out.println(u);
}
//测试生命周期属性init 和 destroy方法
@Test
public void fun5() {
//1、创建容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("cn/ctgu/create/applicationContext.xml");
//2、向容器"要"user对象
User u=(User)ac.getBean("user");
//3、打印user对象
System.out.println(u);
//关闭容器，触发销毁方法
((AbstractApplicationContext) ac).close();
}
}案例————将Spring容器应用到Struts-crm项目中
762
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
