JavaWeb學習之Spring框架（一）

Spring負責管理項目中的全部對象，Spring看做是項目中對象的管家

Spring框架的功能：aop支持、ioc思想、spring jdbc、aop事務、junit測試支持

Spring搭建：

導包：beans、context、core、exception四個基礎包

      apache日誌包

建立實體類對象

書寫配置文件：建議文件名爲applicationContext.xml

      導入約束文件Schema約束

代碼測試：1、建立容器對象

    ApplicationContext ac=new ClassPathXmlApplicationContext(「applicationContext.xml」);

二、從容器中得到實體對象

        User  user=(User)ac.getBean(「User」);   

三、打印該對象

        System.out.println(user);

Spring思想：

ioc:反轉控制

   反轉控制就是建立對象的方式反轉了。之前對象的建立由開發人員本身維護，包括依賴關係也是本身注入；使用spring以後，對象的建立以及以來關係能夠由spring完成建立以及注入。

   反轉控制就是反轉了對象的建立方式。從咱們本身建立反轉給了程序

di:依賴注入（注入就是賦值）

  實現ioc思想須要di作支持

  注入的方式：set方法注入、構造方法注入、字段注入

  注入的類型：值類型注入---8大基本數據類型

              引用類型注入---將依賴對象注入

ApplicationContext&BeanFactory

   BeanFactory接口：spring原始接口，針對原始接口的實現類功能較爲單一

             BeanFactory接口實現類的容器，特色是每次在得到對象時纔會建立對象

  ApplicationContext:每次容器啓動時就建立容器中配置的全部對象，並提供更多的功能

        從類路徑下加載配置文件：ClassPathXmlApplicatiionContext

     從硬盤絕對路徑下加載配置文件：FileSystemXmlApplicationContext(d:/aaa/ddd/fff)

     總結：在web開發中，使用applicationContext,在資源匱乏時使用BeanFactory。

Spring配置文件詳解：

     Bean元素：

        將User對象交給spring容器管理

        Bean元素：使用該元素描述須要spring容器管理的對象

           Class屬性：被管理對象的完整類名

           name屬性：給被管理的對象起個名字。得到對象時根據該名稱得到對象，能夠重複，可使用特殊字符（儘可能使用name屬性）

           id屬性：與name屬性如出一轍，可是名稱不可重複，不能使用特殊字符

      Spring建立對象的方式：

           空參構造方式：<bean  name=」user」  class=」com.domain.User」></bean>

     Bean元素進階：

        Scope屬性

           Singleton（默認值）：單例對象，被標識爲單例的對象在spring容器中只會存在一個實例

           Prototype：多例原型，被標識爲多例的對象，每次再得到再會建立，每次建立都是新的對象。

       Spring的分模塊配置

        <!--導入其餘spring配置文件-->

        <import  resource=」com.domain/applicationContext.xml」/>

Spring屬性注入：

  Set方法注入

  構造函數注入

  複雜類型注入（數組、list、map、properties）

 

<?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 ">
	<!-- 將User對象交給Spring容器來管理 -->
	<!-- 經過set方法進行注入 -->
	<bean name="user" class="com.domain.User">
		<!-- 值注入，也就是變量賦值 -->
		<property name="name" value="張三"></property>
		<property name="age" value="18"></property>
		<!-- 引用類型注入 -->
		<property name="car" ref="car"></property>
	</bean>
	<bean name="car" class="com.domain.Car">
		<!-- 值注入 -->
		<property name="cname" value="蘭博基尼"></property>
		<property name="color" value="黃色"></property>
	</bean>

	<!-- 經過構造方法進行注入 -->
	<bean name="user1" class="com.domain.User">
		<constructor-arg name="name" value="8" index="0" type="java.lang.Integer"></constructor-arg>
		<constructor-arg name="car" ref="car" index="1"></constructor-arg>
	</bean>
</beans>

 

　　

<?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 ">
	<!-- 經過set方法進行注入 -->
	<bean name="user" class="com.domain.User">
		<!-- 值注入，也就是變量賦值 -->
		<property name="name" value="張三"></property>
		<property name="age" value="18"></property>
		<!-- 引用類型注入 -->
		<property name="car" ref="car"></property>
	</bean>
	<bean name="car" class="com.domain.Car">
		<!-- 值注入 -->
		<property name="cname" value="蘭博基尼"></property>
		<property name="color" value="黃色"></property>
	</bean>
	<bean name="cd" class="com.collection.CollectionDemo">
		<!-- 數組 -->
		<property name="arr">
			<array>
				<!-- 值注入 -->
				<value>張三</value>
				<value>李四</value>
				<!-- 引用注入 -->
				<ref bean="user" />
			</array>
		</property>
		<!-- List集合 -->
		<property name="list">
			<list>
				<value>孫悟空</value>
				<value>豬八戒</value>
				<ref bean="car" />
			</list>
		</property>
		<!-- Map類型注入 -->
		<property name="map">
			<map>
				<entry key="123" value="asd"></entry>
				<entry key="user" value-ref="car"></entry>
				<entry key-ref="user" value-ref="car"></entry>
			</map>
		</property>
		<!-- properties類型注入 -->
		<property name="prop">
			<props>
				<prop key="driver">123</prop>
				<prop key="username">root</prop>
				<prop key="password">123456</prop>
			</props>
		</property>
	</bean>

</beans>

 

 

package com.collection;

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.domain.User;

public class Demo {
	@Test
	public void method1() {
		// 1.獲得容器對象
		ApplicationContext ac = new ClassPathXmlApplicationContext("com/collection/applicationContext.xml");
		// 2.管容器要一個對象
		CollectionDemo cd = (CollectionDemo) ac.getBean("cd");
		Object[] obj = cd.getArr();
		for (Object o : obj) {
			System.out.println(o);
		}
	}

	@Test
	public void method2() {
		// 1.獲得容器對象
		ApplicationContext ac = new ClassPathXmlApplicationContext("com/collection/applicationContext.xml");
		// 2.管容器要一個對象
		CollectionDemo cd = (CollectionDemo) ac.getBean("cd");
		// 管對象要一個list
		List list = cd.getList();
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}

	@Test
	public void method3() {
		// 1.獲得容器對象
		ApplicationContext ac = new ClassPathXmlApplicationContext("com/collection/applicationContext.xml");
		// 2.管容器要一個對象
		CollectionDemo cd = (CollectionDemo) ac.getBean("cd");
		// 管對象要一個map
		Map map = cd.getMap();
		Set set = map.entrySet();
		Iterator<Map.Entry> it = set.iterator();
		while (it.hasNext()) {
			Map.Entry m = it.next();
			System.out.println(m.getKey() + "---" + m.getValue());
		}
	}

	@Test
	public void method4() {
		// 1.獲得容器對象
		ApplicationContext ac = new ClassPathXmlApplicationContext("com/collection/applicationContext.xml");
		// 2.管容器要一個對象
		CollectionDemo cd = (CollectionDemo) ac.getBean("cd");
		// 管對象要一個properties
		Properties prop = cd.getProp();
		Set<String> set = prop.stringPropertyNames();
		for (String str : set) {
			System.out.println(str + "--" + prop.getProperty(str));
		}
	}
}

 

　　

 

使用註解配置spring

一、爲主配置文件引入新的命名空間（約束）

二、開啓使用註解代理配置文件

三、在類中使用註解完成配置

將對象注入到容器

@Component(「user」)

  @Service(「user」)  //service層

  @Controller(「user」)  //web層

  @Repository(「user」)  //dao層

修改對象的做用範圍

@Scope(scopeName=」prototype」)

值類型注入：@Value(「tom」)

            Private  String  name;//經過反射的Field賦值，破壞了封裝性

            @Value(「tom」)

            Public void  setName(String  name){

           This.name=name;

}//經過set方法賦值，推薦使用

引用類型注入：@Autowired//自動裝配

          @Qualifier(「car」)//使用@Qualifier註解告訴spring容器自動裝配哪一個名稱的對象

              Private  Car  car;  //兩個配置使用

初始化|銷燬方法

@PostConstruct  //在對象被建立後調用，init-method

@PreDestory   //在銷燬以前調用，destory-method

 

Spring與Junit整合測試：

 

   導包：基礎包4個和日誌包兩個+aop+test

 

   配置註解：@RunWith(SpringJunit4ClassRunner.class)//幫咱們建立容器

 

            @ContextConfiguration(「classpath:applicationContext.xml」)//指定建立容器時使用哪一個配置文件

 

   測試

 

package com.service;

//目標對象(UserService被代理的對象)
public class UserService {
	public void add() {
		System.out.println("這是新增的方法");
	}

	public void delete() {
		System.out.println("這是刪除的方法");
	}

	public void update() {
		System.out.println("這是更新的方法");
	}

	public void find() {
		System.out.println("這是查找的方法");
	}
}

 

　　

package com.service;

//spring與Junit的整合，適用於測試
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.domain.User;

//建立容器
@RunWith(SpringJUnit4ClassRunner.class)
// 指定建立容器時使用哪一個配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo01 {
	@Autowired
	@Qualifier("userService")
	private UserService userService;

	@Test
	public void method() {
		userService.add();
	}
}

　　

 

 

aop思想

 

     Spring可以爲容器中管理的對象生成動態代理對象

 

     動態代理（優先）：被代理的對象必須實現接口，才能產生代理對象，若是沒有，將不能產生動態代理技術

 

     Cglib代理（沒有接口）：第三方代理技術，cglib代理。能夠對任何類生成代理。代理的原理是對目標對象進行繼承代理。若是目標對象被final修飾，那麼該類沒法被cglib代理。

 

名詞學習：

 

     Joinpoint(鏈接點)：目標對象中，全部能夠加強的方法

 

     Pointcut（切入點）：目標對象，已經加強的方法

 

     Advice（通知/加強）：加強的代碼

 

     Target（目標對象）：被代理對象

 

     Weaving（織入）：將通知應用到切入點的過程

 

     Proxy（代理）：將通知織入到目標對象以後，造成代理對象

 

     Aspect（切面）：切入點+通知

 

package com.service;

import org.aspectj.lang.ProceedingJoinPoint;

//通知
public class MyAdvice {
	// 前置通知
	public void before() {
		System.out.println("這是前置通知");
	}

	// 後置通知
	public void afterReturning() {
		System.out.println("這是後置通知，在異常的時候不調用");
	}

	// 環繞通知
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("這是環繞通知以前的部分");
		Object proceed = pjp.proceed();
		System.out.println("這是環繞通知以後的部分");
		return proceed;
	}

	// 異常通知
	public void afterException() {
		System.out.println("這是異常通知，在出現異常的時候調用");
	}

	// 後置通知
	public void after() {
		System.out.println("後置通知，在出現異常的時候調用");
	}
}

 

　　

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd ">
     <!-- 配置目標對象 -->
     <bean name="userService" class="com.service.UserService"></bean>
    <!-- 配置通知 -->
     <bean name="myAdvice" class="com.service.MyAdvice"></bean>
     <!-- 配置切入點 -->
     <aop:config>
           <aop:pointcut expression="execution(* com.service.*Service.*(..))" id="pc"/>
           <aop:aspect ref="myAdvice">
                  <aop:before  method="before" pointcut-ref="pc"/>
                  <aop:after-returning method="afterReturning" pointcut-ref="pc"/>
                  <aop:around method="around" pointcut-ref="pc"/>
                  <aop:after-throwing method="afterException" pointcut-ref="pc"/>
                  <aop:after method="after" pointcut-ref="pc"/>
           </aop:aspect>
     </aop:config>
</beans>