spring框架入門學習
1. Spring概述
1.1. Spring是什么
J2EE三層架構體系
l 表現層（頁面數據顯示、頁面跳轉調度）jsp/servlet
l 業務層（業務處理和功能邏輯、事務控制）-serivice
l 持久層（數據存取和封裝、和數據庫打交道）dao
一站式：
Spring提供了JavaEE各層的解決方案，表現層：Spring MVC，持久層：JdbcTemplate、ORM框架整合，業務層：IoC、AOP、事務控制。
輕量級：Spring的出現取代了EJB的臃腫、低效、繁瑣復雜、脫離現實。
1.2. Spring體系架構
1.3. Spring的核心技術
IoC（Inverse of Control 反轉控制）： 將對象創建權利交給Spring工廠進行管理。
AOP（Aspect Oriented Programming 面向切面編程），基于動態代理功能增強。
1.4. 為什么要學習Spring
2. Spring IOC快速入門
2.1. 什么是IOC
Inverse of Control，控制反轉，將對象的創建權力反轉給Spring框架！！
解決問題：使用IOC可以解決的程序耦合性高的問題！！
2.2. IOC的原理
2.2.1.準備工作
創建UserDao接口及其實現類UserDaoImpl
package cn.baidu.dao;
public interface UserDao {
public void save();
}
package cn.baidu.dao.impl;
import cn.baidu.dao.UserDao;
public class UserDaoImpl implements UserDao {
@Override
public void save() {
System.out.println("持久層：用戶保存");
}
}
創建UserService接口及其實現類UserServiceImpl
package cn.baidu.service;
public interface UserService {
public void save();
}package cn.baidu.service.impl;
import cn.baidu.dao.UserDao;
import cn.baidu.dao.impl.UserDaoImpl;
import cn.baidu.service.UserService;
publicclass UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public void save() {
System.out.println("業務層：用戶保存");
userDao.save();
}
}
2.2.2.創建測試類測試
package cn.baidu.test;
import org.junit.Test;
import cn.baidu.service.UserService;
import cn.baidu.service.impl.UserServiceImpl;
publicclass Test1 {
@Test
public void test(){
UserService userService = new UserServiceImpl();
userService.save();
}
}
創建另一個UserDao的實現UserDaoImpl2
package cn.baidu.dao.impl;
import cn.baidu.dao.UserDao;
public class UserDaoImpl2 implements UserDao{
@Override
public void save() {
System.out.println("持久層：用戶保存2");
}
}
觀察以上程序發現：UserService和UserDao耦合性過高，如果需要換一個UserDao的實現，則需要更改源代碼。
2.2.3.創建工廠類解決耦合性的問題
package cn.baidu.utils;
import cn.baidu.dao.UserDao;
import cn.baidu.dao.impl.UserDaoImpl;
public class BeanFactory {
public static UserDao getBean(){
return new UserDaoImpl();
}
}修改UserServiceImpl實現類獲取UserDao的方式
public class UserServiceImpl implements UserService {
// private UserDao userDao = new UserDaoImpl();
// 采用工廠類獲取UserDao對象
private UserDao userDao = BeanFactory.getBean();
@Override
public void save() {
System.out.println("業務層：用戶保存");
userDao.save();
}
}
觀察發現：當需要更換UserDao的實現時，不需要更改UserServiceImpl類，但還是要更改工廠類。
2.2.4.創建配置文件徹底解決耦合性的問題
在src下創建配置文件beans.xml
<?xml version="1.0"encoding="UTF-8"?>
<bean id="userDao"class="cn.baidu.dao.impl.UserDaoImpl2"></bean>
修改工廠類，從配置文件讀取對象
public class BeanFactory {
//存放所有的對象
private static final Map<String,Object>map = new HashMap<String,Object>();
static{
SAXReader sax = new SAXReader();
try {
Document document = sax.read(BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml"));
Element root = document.getRootElement();
//獲取id屬性的值
String id = root.attributeValue("id");
//獲取class屬性的值
String value = root.attributeValue("class");
//根據class屬性的值實例化對象
Object obj = Class.forName(value).newInstance();
//把對象存放到Map中
map.put(id, obj);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 根據id獲取對象
* @param id
* @return
*/
public static Object getBean(String id){
return map.get(id);
}
}
修改UserServiceImpl類
public class UserServiceImpl implements UserService {
// private UserDao userDao = new UserDaoImpl();
// 采用工廠類獲取UserDao對象
// private UserDao userDao = BeanFactory.getBean();
// 從配置文件中讀取需要的對象
private UserDao userDao = (UserDao) BeanFactory.getBean("userDao");
@Override
public void save() {
System.out.println("業務層：用戶保存");
userDao.save();
}
}
觀察發現：當需要更改UserDao時，只需要更改配置文件就行，不用更改源代碼，程序徹底解耦了！！！
2.3. Spring開發包
官網地址：https://spring.io/
下載網址：http://repo.spring.io/libs-release-local/org/springframework/spring/
本次學習采用4.2.4這個版本
開發包目錄結構
開發過程中還需要其他開源技術框架依賴Jar包集（dependencies，作用是方便依賴的其他技術的jar的導入）：
2.4. Spring IOC入門
2.4.1.新建Java工程spring4_day01，導入jar包
Spring核心容器需要四個jar包
同時還需要與日志相關的兩個jar包，從spring-framework-3.0.2.RELEASE-dependencies中尋找
復制log4j.properties到src下：
如何在Java工程中導入jar包？
在Java工程中新建一個目錄lib，把需要導入的jar包復制到lib下，右鍵需要導入的jar包，build path，添加到項目中
2.4.2.創建一個接口和實現類
package cn.baidu.dao;
public interface UserDao {
public void save();
}
package cn.baidu.dao.impl;
import cn.baidu.dao.UserDao;
public class UserDaoImpl implements UserDao {
@Override
public void save() {
System.out.println("用戶保存...");
}
}
2.3.4.創建Spring的核心配置文件
在src下新建Spring核心配置文件applicationContext.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
2.4.4.配置UserDaoImpl類
<?xml version="1.0"encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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.xsd">
<bean id="userDao"class="cn.baidu.dao.impl.UserDaoImpl"></bean>
</beans>
2.4.5.編寫測試類
public class Test1 {
@Test
public void test1(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.save();
}
}
3. Spring中的工廠
3.1. ApplicationContext接口
使用ApplicationContext工廠的接口，使用該接口可以獲取到具體的Bean對象
接口下有兩個具體的實現類
*ClassPathXmlApplicationContext --加載類路徑下的Spring配置文件
*FileSystemXmlApplicationContext --加載本地磁盤下的Spring配置文件
public class Test1 {
@Test
public void test1(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.save();
}
@Test
public void test2(){
ApplicationContext applicationContext = new FileSystemXmlApplicationContext("C:/spring/applicationContext.xml");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.save();
}
}
3.2. BeanFactory工廠
BeanFactory是Spring框架早期的創建Bean對象的工廠接口
/**
* 早期版本的spring工廠：BeanFactory
*/
@Test
public void test3(){
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
System.out.println("工廠對象創建出來了");
UserDao userDao = (UserDao) factory.getBean("userDao");
userDao.save();
}
BeanFactory和ApplicationContext的區別
*BeanFactory --BeanFactory采取延遲加載，第一次getBean時才會初始化Bean
*ApplicationContext -- 在加載applicationContext.xml時候就會創建具體的Bean對象的實例，還提供了一些其他的功能:
* 事件傳遞
* Bean自動裝配
* 各種不同應用層的Context實現
4. Spring配置文件
4.1. id屬性
id屬性是bean的唯一標識
4.2. class屬性
bean的全路徑名
<bean id="userDao"class="cn.baidu.dao.impl.UserDaoImpl"/>4.3. scope屬性
scope屬性代表Bean的作用范圍
singleton:單例（默認值）
prototype:多例，在Spring框架整合Struts2框架的時候，Action類也需要交給Spring做管理，配置把Action類配置成多例！！
request:應用在web應用中，將創建的對象存入到request域中。
session:應用在web應用中，將創建的對象存入到session域中
globalsession:應用在porlet環境下使用。將創建的對象存入到全局的session中。<bean id="userDao"class="cn.baidu.dao.impl.UserDaoImpl"scope="prototype"/>修改測試類：
@Test
public void test1(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("工廠對象創建出來了");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
UserDao userDao1 = (UserDao) applicationContext.getBean("userDao");
userDao.save();
}
測試發現：當scope為prototype時，每次獲取bean，都會重新實例化
4.4. init-method屬性
當bean被載入到容器的時候調用init-method屬性指定的方法
public class UserDaoImpl implements UserDao {
public UserDaoImpl() {
System.out.println("調用了UserDaoImpl的構造方法");
}
public void init(){
System.out.println("調用了init方法...");
}
@Override
public void save() {
System.out.println("用戶保存...");
}
}
<bean id="userDao"class="cn.baidu.dao.impl.UserDaoImpl"init-method="init"/>
4.5. destory-method屬性
當bean從容器中刪除的時候調用destroy-method屬性指定的方法
想查看destroy-method的效果，有如下條件：
scope= singleton有效
web容器中會自動調用，但是main函數或測試用例需要手動調用（需要使用ClassPathXmlApplicationContext的close()方法）
@Test
public void test1(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("工廠對象創建出來了");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.save();
//要看到destroy方法執行，需要調用ClassPathXmlApplicationContext.close方法
((ClassPathXmlApplicationContext)applicationContext).close();
}
5. Spring生成bean的三種方式
5.1. 無參構造方法
默認調用無參構造方法實例化bean
5.2. 靜態工廠實例化方式
通過調用工廠類的靜態方法來生成bean
編寫DepartmentDao接口
package cn.baidu.dao;
publicinterface DepartmentDao {
public void save();
}
編寫DepartmentDaoImpl實現類
package cn.baidu.dao.impl;
import cn.baidu.dao.DepartmentDao;
public class DepartmentDaoImpl implements DepartmentDao{
@Override
public void save() {
System.out.println("部門保存...");
}
}
編寫工廠類
package cn.baidu.dao.impl;
import cn.baidu.dao.DepartmentDao;
public class DepartmentDaoFactory {
/**
* 靜態工廠方法獲取對象
* @return
*/
public static DepartmentDao create(){
return new DepartmentDaoImpl();
}
}
<?xml version="1.0"encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
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.xsd">
<bean id="userDao" class="cn.baidu.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>
<bean id="departmentDao" class="cn.baidu.dao.impl.DepartmentDaoFactory" factory-method="create"></bean>
</beans>
5.3. 實例工廠實例化方式
實例工廠代碼:
package cn.baidu.dao.impl;
import cn.baidu.dao.DepartmentDao;
public class DepartmentDaoFactory {
/**
* 靜態工廠方法獲取對象
* @return
*/
public static DepartmentDao create(){
return new DepartmentDaoImpl();
}
/**
* 實例工廠方法獲取對象
* @return
*/
public DepartmentDao create1(){
return new DepartmentDaoImpl();
}
}
編寫applicationContext.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userDao" class="cn.baidu.dao.impl.UserDaoImpl" init-method="init "destroy-method="destory"/>
<!-- <bean id="departmentDao" class="cn.baidu.dao.impl.DepartmentDaoFactory" factory-method="create"></bean> -->
<bean id="departmentDaoFactory" class="cn.baidu.dao.impl.DepartmentDaoFactory"></bean>
<bean id="departmentDao" factory-bean="departmentDaoFactory" factory-method="create1"></bean>
</beans>
6. 依賴注入
6.1. 什么是依賴注入
IOC和DI的概念：
*IOC -- Inverse of Control，控制反轉，將對象的創建權反轉給Spring！！
*DI -- Dependency Injection，依賴注入，在Spring框架負責創建Bean對象時，動態的將依賴對象注入到Bean組件中！！
如果UserServiceImpl的實現類中有一個屬性，那么使用Spring框架的IOC功能時，可以通過依賴注入把該屬性的值傳入進來！！
6.2. 構造方法注入
Car實體類
package cn.baidu.domain;
public class Carimplements Serializable{
privatestaticfinallongserialVersionUID = 1L;
private String name;
private Double price;
public Car(String name, Double price) {
this.name = name;
this.price = price;
}
public String getName() {
returnname;
}
public void setName(String name) {
this.name = name;
}
public Double getPrice() {
returnprice;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return"Car [name=" + name + ", price=" + price + "]";
}
}
配置applicationContext.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userDao" class="cn.baidu.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>
<!-- <bean id="departmentDao" class="cn.baidu.dao.impl.DepartmentDaoFactory" factory-method="create"></bean> -->
<bean id="departmentDaoFactory" class="cn.baidu.dao.impl.DepartmentDaoFactory"></bean>
<bean id="departmentDao" factory-bean="departmentDaoFactory" factory-method="create1"></bean>
<!-- 構造方法注入 -->
<bean id="car" class="cn.baidu.domain.Car">
<constructor-arg name="name" value="奧迪A6"></constructor-arg>
<constructor-arg name="price" value="57.3"></constructor-arg>
</bean>
</beans>
運行結果：
6.3. set方法注入
Student實體類
public class Student implements Serializable {
privatestaticfinallongserialVersionUID = 1L;
private Long id;
private String name;
public Long getId() {
returnid;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
returnname;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return"Student [id=" + id + ", name=" + name + "]";
}
}
配置applicationContext.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userDao" class="cn.baidu.dao.impl.UserDaoImpl" init-method="init" destroy-method="destory"/>
<!-- <bean id="departmentDao" class="cn.baidu.dao.impl.DepartmentDaoFactory" factory-method="create"></bean> -->
<bean id="departmentDaoFactory" class="cn.baidu.dao.impl.DepartmentDaoFactory"></bean>
<bean id="departmentDao" factory-bean="departmentDaoFactory" factory-method="create1"></bean>
<!-- 構造方法注入 -->
<bean id="car" class="cn.baidu.domain.Car">
<constructor-arg name="name" value="奧迪A6"></constructor-arg>
<constructor-arg name="price" value="57.3"></constructor-arg>
</bean>
<!-- set方法注入 -->
<bean id="student" class="cn.baidu.domain.Student">
<property name="id" value="11"></property>
<property name="name" value="張三"></property>
</bean>
</beans>
測試結果：
注意：采用set方法注入時，類中一定要有無參構造方法，因為spring會先調用無參構造方法實例化對象。
6.4. set方法注入對象
People實體類
public class People implements Serializable {
privatestaticfinallongserialVersionUID = 1L;
private Long id;
private String name;
private Car car;
public Long getId() {
returnid;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
returnname;
}
public void setName(String name) {
this.name = name;
}
public Car getCar() {
returncar;
}
public void setCar(Car car) {
this.car = car;
}
@Override
public String toString() {
return"People [id=" + id + ", name=" + name + ", car=" + car + "]";
}
}
配置applicationContext.xml
<!-- set方法注入對象 -->
<bean id="people" class="cn.baidu.domain.People">
<property name="name" value="小明"></property>
<property name="car" ref="car"></property>
</bean>
6.5. set方法其它注入寫法
通過set方法注入還有其它兩種寫法：
6.5.1.p命名空間的寫法
新建Car1類
package cn.baidu.domain;
public class Car1 {
private String name;
private double price;
public void setName(String name) {
this.name = name;
}
public void setPrice(doubleprice) {
this.price = price;
}
@Override
public String toString() {
return"Car1 [name=" + name + ", price=" + price + "]";
}
}
在applicationContext.xml中引入p命名空間
采用p:屬性名的形式注入值（spring2.5提供的）
<!-- p命名空間注入 -->
<bean id="car1" class="cn.baidu.domain.Car1" p:name="奔馳" p:price="100.2">
</bean>
6.5.2.SpEL的寫法（spring3.0提供）
<!-- SpEL注入 -->
<bean id="car1" class="cn.baidu.domain.Car1">
<property name="name" value="#{'哈弗H5'}"></property>
<property name="price" value="#{10}"></property>
</bean>
注入字符串：#{‘字符串’}
注入數字：#{數字}
注入其它對象：#{對象id}
<bean id="people" class="cn.baidu.domain.People">
<property name="name" value="#{'小明'}"></property>
<property name="car" value="#{car}"></property>
</bean>
還可以注入其它對象的屬性或方法的返回值
public class CarInfo {
public String getCarName(){
return "寶駿560";
}
public double calculatePrice(){
return Math.random() * 10000;
}
}
<bean id="carInfo"class="cn.baidu.domain.CarInfo"></bean>
<!-- SpEL注入 -->
<bean id="car1" class="cn.baidu.domain.Car1">
<!-- <property name="name" value="#{'哈弗H5'}"></property>
<property name="price" value="#{10}"></property> -->
<property name="name" value="#{carInfo.carName}"></property>
<property name="price" value="#{carInfo.calculatePrice()}"></property>
</bean>
注意：#{carInfo.carName}會調用getCarName方法獲取汽車的名稱；而#{carInfo.calculatePrice()}會直接調用calculatePrice方法獲取汽車價格。
6.6. 數組或list注入
數組和list注入的寫法是一樣的
新建bean類
public class CollectionBean {
private String[] array;
public void setArray(String[] array) {
this.array = array;
}
@Override
public String toString() {
return"CollectionBean [array=" + Arrays.toString(array) + "]";
}
}
在applicationContext.xml中配置
<bean id="collectionBean" class="cn.baidu.domain.CollectionBean">
<property name="array">
<list>
<value>威少</value>
<value>哈登</value>
<value>萊昂納德</value>
</list>
</property>
</bean>
6.7. Set集合的注入
public class CollectionBean {
private String[] array;
private Set<String>set;
public void setArray(String[] array) {
this.array = array;
}
public void setSet(Set<String>set) {
this.set = set;
}
@Override
public String toString() {
System.out.println(set.getClass());
return"CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + "]";
}
}
<bean id="collectionBean" class="cn.baidu.domain.CollectionBean">
<property name="array">
<list>
<value>威少</value>
<value>哈登</value>
<value>萊昂納德</value>
</list>
</property>
<property name="set">
<set>
<value>蘋果</value>
<value>梨子</value>
<value>香蕉</value>
</set>
</property>
</bean>
提示：spring在注入set的時，給我們注入的是一個LinkedHashSet，所以在輸入set集合中的元素時，是按照我們注入的順序來的，并不是無序的。
6.8. Map集合的注入
public class CollectionBean {
private String[] array;
private Set<String>set;
private Map<String,String>map;
public void setArray(String[] array) {
this.array = array;
}
public void setSet(Set<String>set) {
this.set = set;
}
public void setMap(Map<String, String>map) {
this.map = map;
}
@Override
public String toString() {
return"CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + ", map=" + map + "]";
}
}
<bean id="collectionBean" class="cn.baidu.domain.CollectionBean">
<property name="array">
<list>
<value>威少</value>
<value>哈登</value>
<value>萊昂納德</value>
</list>
</property>
<property name="set">
<set>
<value>蘋果</value>
<value>梨子</value>
<value>香蕉</value>
</set>
</property>
<property name="map">
<map>
<entrykey="id"value="11"></entry>
<entrykey="name"value="張三"></entry>
<entrykey="age"value="20"></entry>
</map>
</property>
</bean>
Properties的注入
public class CollectionBean {
private String[] array;
private Set<String>set;
private Map<String,String>map;
private Properties props;
public void setArray(String[] array) {
this.array = array;
}
public void setSet(Set<String>set) {
this.set = set;
}
public void setMap(Map<String, String>map) {
this.map = map;
}
public void setProps(Properties props) {
this.props = props;
}
@Override
public String toString() {
return"CollectionBean [array=" + Arrays.toString(array) + ", set=" + set + ", map=" + map + ", props=" + props
+ "]";
}
}
<bean id="collectionBean" class="cn.baidu.domain.CollectionBean">
<property name="array">
<list>
<value>威少</value>
<value>哈登</value>
<value>萊昂納德</value>
</list>
</property>
<property name="set">
<set>
<value>蘋果</value>
<value>梨子</value>
<value>香蕉</value>
</set>
</property>
<property name="map">
<map>
<entry key="id"value="11"></entry>
<entry key="name"value="張三"></entry>
<entry key="age"value="20"></entry>
</map>
</property>
<property name="props">
<props>
<prop key="username">李四</prop>
<prop key="password">123</prop>
</props>
</property>
</bean>
6.9. 配置文件的分離
Spring配置文件的分離有兩種方式：
（1）采用import標簽導入另一個配置文件
Bean1類Public class Bean1 {
private String xxx;
public String getXxx() {
returnxxx;
}
Public void setXxx(String xxx) {
this.xxx = xxx;
}
@Override
public String toString() {
return "Bean1 [xxx=" + xxx + "]";
}
}
applicationContext2.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.xsd">
<bean id="bean1" class="cn.itcast.demo.Bean1">
<property name="xxx" value="hello"></property>
</bean>
</beans>
在applicationContext.xml中引入applicationContext2.xml文件
<import resource="applicationContext2.xml"/>（2）在實例化ApplicationContext的時候，指定多個配置文件
@Test
public void test9(){
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");
Bean1 bean1 = (Bean1) ac.getBean("bean1");
System.out.println(bean1);
}
智能推薦
Spring MVC框架入門
文章目錄 MVC設計模式簡介 Spring MVC處理用戶請求的完整流程 Spring MVC框架搭建 視圖解析器 Spring MVC獲取請求參數方式&注解 Spring MVC的轉發與重定向 請求參數類型轉換 內容出處： Spring MVC 角色劃分清晰，分工明細，并且和 Spring 框架無縫結合。作為當今業界最主流的 Web 開發框架，Spring MVC 已經成為當前最熱門的開...
Spring框架入門分析
定位 輕量級的企業級 Java 應用程序開發框架，基礎版本只有 2 MB 左右的大小。核心特性是可以用于開發任何 Java 應用程序，但是在 Java EE 平臺上構建 web 應用程序是需要擴展的。 Spring 框架的目標是使 J2EE 開發變得更容易使用，通過啟用基于 POJO 編程模型來促進良好的編程實踐。 架構分析：Core Containe IOC容器： Spring BeanFact...
Spring Boot框架入門學習記錄（一）
首先來學習如何建立一個項目然后輸出hello world！ 一、創建一個maven工程 創建好后如圖 二、導入spring boot相關的依賴 打開pom.xml，這是一個配置文件 org.springframework.boot spring-boot-starter-parent 1.5.9.RELEASE org.springframework.boot spring-boot-starte...
全面學習Spring框架入門與提高(含代碼)
這一篇文章我將和大家一起回顧整個Spring框架技術，由于內容較多，內容共分為三大部分。每一篇都從簡到難地安排了一些小知識點，東西是當時我老師講的，現在將知識點都整理下來，供大家一起討論學習，也方便以后自己復習。如果有不對的地方歡迎大家指正。 1.初識Spring框架，聲明周期和延時加載… 2.注入，自動裝配，注入集合類型，注入properties類型… 3.Sprin...
猜你喜歡
freemarker + ItextRender 根據模板生成PDF文件
1. 制作模板 2. 獲取模板，并將所獲取的數據加載生成html文件 2. 生成PDF文件 其中由兩個地方需要注意，都是關于獲取文件路徑的問題，由于項目部署的時候是打包成jar包形式，所以在開發過程中時直接安照傳統的獲取方法沒有一點文件，但是當打包后部署，總是出錯。于是參考網上文章，先將文件讀出來到項目的臨時目錄下，然后再按正常方式加載該臨時文件； 還有一個問題至今沒有解決，就是關于生成PDF文件...
電腦空間不夠了？教你一個小秒招快速清理 Docker 占用的磁盤空間！
Docker 很占用空間，每當我們運行容器、拉取鏡像、部署應用、構建自己的鏡像時，我們的磁盤空間會被大量占用。 如果你也被這個問題所困擾，咱們就一起看一下 Docker 是如何使用磁盤空間的，以及如何回收。 docker 占用的空間可以通過下面的命令查看： TYPE 列出了docker 使用磁盤的 4 種類型： Images：所有鏡像占用的空間，包括拉取下來的鏡像，和本地構建的。 Con...
requests實現全自動PPT模板
http://www.1ppt.com/moban/ 可以免費的下載PPT模板，當然如果要人工一個個下，還是挺麻煩的，我們可以利用requests輕松下載 訪問這個主頁，我們可以看到下面的樣式 點每一個PPT模板的圖片，我們可以進入到詳細的信息頁面，翻到下面，我們可以看到對應的下載地址 點擊這個下載的按鈕，我們便可以下載對應的PPT壓縮包 那我們就開始做吧 首先，查看網頁的源代碼，我們可以看到每一...
Linux C系統編程-線程互斥鎖（四）
互斥鎖 互斥鎖也是屬于線程之間處理同步互斥方式，有上鎖/解鎖兩種狀態。 互斥鎖函數接口 1）初始化互斥鎖 pthread_mutex_init() man 3 pthread_mutex_init (找不到的情況下首先 sudo apt-get install glibc-doc sudo apt-get install manpages-posix-dev) 動態初始化 int pthread_...
