Spring概述
Spring概述
一、Spring是一个基于IOC和AOP来构架多层JavaEE系统的、企业级的、轻量级的、低倾入的框架（后期项目维护，修改代码量较少）
1.方便解耦，简化开发
Spring就是一个大工厂，生产管理实体bean,不用实例化对象，所有的都是通过Spring容器来进行管理
2.AOP编程的支持
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
3.声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无需手动编程
4.方便程序的测试
Spring对Junit支持，可以通过注解方便的测试Spring程序
5.与其它框架的集合度比较好（ssh,ssm）
6.降低了JavaEE API的使用难度
Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低
二、Spring各个模块的介绍
bean（主要就是管理，产生对象）core（主要提供一些核心基础服务）context（提供API开发）
搭建Spring框架的步骤：
1.导入核心的jar包
2.导入核心配置文件（xml文件）
3.进行测试
三、控制反转（IOC）
1.概念：就是不需要自己来实例化这个对象，而依赖于我们的容器也就是Spring框架，控制权的转移就是所谓的反转，目的是为了获得更好的扩展性和良好的可维护性。
2.代码：
存在一个boy对象
public class Boy implements Serializable {
//说的方法
public void say(){
System.out.println("正在聊天！");
}
}
在Spring容器中定义（配置xml文件）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p ="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<!--id是这个bean唯一标识符-->
<bean id="boy" class="com.offcn.entity.Boy"></bean>
</beans>
测试
public class Test {
public static void main(String[] args) {
// Boy boy = new Boy();
// boy.say();
/**
* 如何加载这个配置文件？
* 1.用全路径
* ApplicationContext app = new FileSystemXmlApplicationContext("D:\\IdeaProjects\\day01\\src\\appliactionContext.xml");
*
* 2.BeanFactory加载配置文件，参数同样是全路径
* BeanFactory app = new XmlBeanFactory(new FileSystemResource("D:\\IdeaProjects\\day01\\src\\appliactionContext.xml"));
*
* 3.类路径
* ApplicationContext app = new ClassPathXmlApplicationContext("appliactionContext.xml");
* 第三种方式是用的做多的一种
* /
ApplicationContext app = new ClassPathXmlApplicationContext("appliactionContext.xml");
Boy boy = (Boy)app.getBean("boy");
boy.say();
}
}
四、依赖注入
1.概念：在运行期间，由外部容器动态地将依赖对象注入到另一个对象的组件中
2.代码：①两个实体类
Boy.java
public class Boy implements Serializable {
//说的方法
public void say(){
System.out.println("正在接吻！");
}
}
Girl.java
public class Girl {
private Boy boy;
//这里要调用男孩的方法
public void kiss(){
boy.say();
}
public void setBoy(Boy boy) {
this.boy = boy;
}
}
②在Spring容器中定义（配置xml文件）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p ="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<bean id="boy" class="com.offcn.entity.Boy"></bean>
<bean id="girl" class="com.offcn.entity.Girl">
<!--name:在Girl对象中的set方法的属性名称
ref:将容器创建的对象注入到set方法中，即id名-->
<property name="boy" ref="boy"></property>
</bean>
</beans>
③测试
public class Test {
public static void main(String[] args) {
ApplicationContext app = new ClassPathXmlApplicationContext("appliactionContext.xml");
Girl girl = (Girl)app.getBean("girl");
girl.kiss();
}
}
五、实例化bean的方式
1.使用接口和实现类，直接在Spring容器中创建一个类，使用接口进行操作
接口：
public interface UserService {
public void add();
}
实现类：
public class UserServiceImpl implements UserService {
@Override
public void add() {
System.out.println("增加成功！");
}
}
配置：
<!--不能配置接口-->
<bean id="user" class="com.offcn.service.impl.UserServiceImpl"></bean>
测试：
public class Text {
public static void main(String[] args) {
ApplicationContext app = new ClassPathXmlApplicationContext("appliactionContext.xml");
UserService user = (UserService) app.getBean("user");
user.add();
}
}
2.使用静态工厂方法实例化（简单工厂模式）
// 用静态工厂的方式来产生这个对象
public static UserService createUserService(){
return new UserServiceImpl();
}
用静态模式来实例化对象
<bean id="userObject" class="com.offcn.utils.UserObject" factory-method="createUserService"></bean>
UserService user2 = (UserService)app.getBean("userObject");
user2.add();
3.使用非静态方法实例化
// 使用非静态的来实例这个对象
public UserService createUserService(){
return new UserServiceImpl();
}
// 使用非静态的方式来实例这个对象
<bean id="userObject" class="com.offcn.utils.UserObject"></bean>
<bean id="users" factory-bean="userObject" factory-method="createUserService"></bean>
UserService user3 = (UserService)app.getBean("users");
user3.add();
六、注入方式
1.依赖注入手动装配（set方法和构造方法）
①以p命名方式来赋值
public class Person {
private int pid;
private String pname;
public int getPid() {
return pid;
}
public void setPid(int pid) {
this.pid = pid;
}
public String getPname() {
return pname;
}
public void setPname(String pname) {
this.pname = pname;
}
}
<!-- 以P命名的方式来赋值-->
<bean id="person" class="com.offcn.entity.Person" p:pid="123" p:pname="wha"></bean>
②用构造方法赋值
public class Student implements Serializable {
private int sid;
private String sname;
private String spwd;
public Student(int sid, String sname) {
this.sid = sid;
this.sname = sname;
}
public Student(String sname, String spwd) {
this.sname = sname;
this.spwd = spwd;
}
public Student(int sid, String sname, String spwd) {
this.sid = sid;
this.sname = sname;
this.spwd = spwd;
}
public void print(){
System.out.println(sid+"\t"+sname+"\t"+spwd);
}
}
<bean id="student" class="com.offcn.entity.Student">
<!--用构造的方法进行值的注入，第一个方式是通过索引，这个索引是从0开始
<constructor-arg index="0" value="111"></constructor-arg>
<constructor-arg index="1" value="222"></constructor-arg>
-->
<constructor-arg name="sid" value="111"></constructor-arg>
<constructor-arg name="sname" value="222"></constructor-arg>
</bean>
③用Spring基本属性赋值
public class UserObject {
//赋值
private int sid;
private String sname;
private Person person;
private List list;
private Set set;
private Map<String, String> map;
private Object [] objects;
public void setObjects(Object[] objects) {
this.objects = objects;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public void setSet(Set set) {
this.set = set;
}
public void setList(List list) {
this.list = list;
}
public void setSid(int sid) {
this.sid = sid;
}
public void setSname(String sname) {
this.sname = sname;
}
public void setPerson(Person person) {
this.person = person;
}
public void print() {
System.out.println(sid + "\t" + sname + "\t" + person.getPid() + "\t" + person.getPname());
if (list != null && list.size() > 0) {
for (Object o : list) {
System.out.println(o);
}
}
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
Set<String> key = map.keySet();
Iterator<String> it = key.iterator();
while (it.hasNext()) {
String n = it.next();
System.out.println(n + "\t" + map.get(n));
}
if(objects!=null&&objects.length>0){
for (int i=0;i<objects.length;i++){
System.out.println(objects[i]);
}
}
}
}
<!-- 用Spring给基本属性赋值-->
<bean id="userObject" class="com.offcn.utils.UserObject">
<property name="sid" value="11"></property>
<property name="sname" value="wanghaoan"></property>
<property name="person" ref="person"></property>
<!--配置list集合-->
<property name="list">
<list>
<value>qqq</value>
<value>www</value>
<value>hhh</value>
<value>aaa</value>
</list>
</property>
<!--配置set集合-->
<property name="set">
<set>
<value>nnn</value>
<value>rrr</value>
<value>kkk</value>
</set>
</property>
<!--配置map集合-->
<property name="map">
<map>
<entry key="01">
<value>编号01</value>
</entry>
<entry key="02">
<value>编号02</value>
</entry>
<entry key="03">
<value>编号03</value>
</entry>
</map>
</property>
<!--配置数组-->
<property name="objects">
<array>
<value>zzz</value>
<value>ggg</value>
<value>ppp</value>
</array>
</property>
</bean>
2.注解注入（JDK1.6以上）
Dao层：@Repository用于标注数据访问组件，即Dao层
public interface UserDao {
//增加方法
public void add();
}
//dao层的注解是固定的 记住就好
@Repository("userDao")
public class UserDaoImpl implements UserDao {
@Override
public void add() {
System.out.println("增加成功了！");
}
}
Service层：@Service用于标注业务层 \ @Autowired自动按类型装配@Qualifier(“userDao”)可标注在方法参数里（连用） || @Resource自动按名称装配
public interface UserService {
public void add();
}
@Service("userService")
public class UserServiceImpl implements UserService {
//代表自动装配
//@Autowired
//@Qualifier("userDao")
//用的是java的注解来进行装配，jdk的版本必须在1.6以上
@Resource
private UserDao userDao;
/*
public void setUserDao(@Qualifier("userDao") UserDao userDao) {
this.userDao = userDao;
}
*/
@Override
public void add() {
userDao.add();
}
}
配置文件xml：
<?xml version="1.0" encoding="UTF-8"?>
<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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<!-- 扫描包中注解标注的类 -->
<context:component-scan base-package="com.offcn.service,com.offcn.dao" />
</beans>
测试：
public class Test {
//获取配置文件
public static void main(String[] args) {
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService user = (UserService)app.getBean("userService");
user.add();
}
}