1.Spring
package Test;
import java.util.Calendar;
import org.junit.Test;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.aFirstHello;
import pojo.cSingletonUser;
import pojo.dLifeUser;
import pojo.eUserDI;
//进行单元测试类
public class TestSping {
//-------------------------1.sping的IOC入门------------------------------------------
/*
知识点1.1:spring的IOC（控制反转）
IOC：inversion of control
IOC：就是讲对象创建的权利交给spring，而程序员无需去关注对象的生命周期。
以前:Person person = new Person(); //程序员手动编写
现在:Person person = spring容器.getBean();//spring容器负责对象的创建
步骤:
a.导入jar包
b.编写了Hello的实体类
c.编写了核心配置文件 ： applicationContext.xml 最好命名为该名称
d.编写了单元测试类：TestSpring
> 启动spring容器
> 通过spring容器获取bean
> 调用Hello对象的say()方法
知识点1.2:spring的IOC的原理
第一步:sping容器的创建,加载了配置文件中的信息。
1.1 当spring容器启动时，找到了对应的核心配置文件applicationContext.xml
1.2 当加载配置文件时，逐行的读取xml配置，然后遇到bean标签时，进行解析
1.3 bean标签的id属性，解析为map中的key，bean标签的class属性，解析时通过java的反射机制，创建了Hello对象，同时，把value值放入了map中的value中
第二步:从sping容器中map获取对象 key:
2.1使用map中的id属性的值，获取了map中的对象。
如果根据配置文件解析时出错,那么spring容器将不能正常启动.不能为用户提供服务. 如果容器启动正常 则xml配置一定没错.
知识点1.3 sping获取map对象
a.通过id的值
b.通过class属性
*/
//sping的IOC入门
@Test
public void test01(){
//1.sping容器的创建,加载了配置文件中的信息。
/*
注意1.a：两个相同id的bean出错
异常信息: bean标签中的id不能重复
出错位置:在配置文件加载的时候就出错，第一步就出错。
配置文件中
<bean id="hello" class="pojo.Hello"></bean>
<bean id="hello" class="pojo.Hello"></bean>
*/
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.从sping容器中map获取对象 key:id属性的值,value:创建出来的对象
//注意:Hello hello=(Hello) context.getBean(Hello.class); sping获取对象的方式2：class类型，不会报错
aFirstHello hello=(aFirstHello) context.getBean("hello"); // sping获取对象的方式1：id属性的值
/*
注意1.b两个相同class属性的bean
异常信息： 找不到唯一的class
出错位置：加载文件时不报错，在map取值时报错了
配置文件
<bean id="hello" class="pojo.Hello"></bean>
<bean id="helloA" class="pojo.Hello"></bean>
测试类中
Hello hello=(Hello) context.getBean(Hello.class);
在第二步报错，加载文件时报错，在map取值时报错，找不到唯一的class.
*/
//3.调用hello对象中的方法
hello.say();
}
//别名标签的使用
/*
配置文件中
<bean id="hello" class="pojo.aFirstHello"></bean>
<alias name="hello" alias="1806班"></alias>
别名标签:alias
name:引用bean的id的值
alias:程序员根据自己习惯，定义的名称，避免了重复的bean标签出现
*/
@Test
public void test02(){
//1.sping容器的创建,加载了配置文件中的信息。
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
//2.从sping容器中map获取对象 key:
aFirstHello hello=(aFirstHello) context.getBean("1806班");
//3.调用hello对象中的方法
hello.say();
}
//-------------------------2.spring容器创建对象的方式-----------------------------------------
/*
有一些类，交给spring容器时去直接创建的时候，没有办法直接new出来。
Hello new Hello() spring可以直接new
Calendar Calender.getInstance() sping无法直接new
知识点2.1
a.默认的使用无参构造 创建对象：必须要有无参构造
b.使用静态的工厂类，在工厂类中写一个getXXX的static静态方法
c.使用非静态的实例工厂类，在工厂类中写一个getXXX的非静态方法
d.使用spring提供的一个接口 ：FactoryBean<Calendar>
建议：以后需要创建对象时，而该对象又不能直接被spring容器管理，那么我们选择spring提供的工厂模式，d.FactoryBean
*/
/*
b静态工厂
工厂类
写一个getXXX的static静态方法，返回对象
public static Calendar getCalendar(){
return Calendar.getInstance();
}
配置文件中
factory-method="" 表示静态工厂中的静态方法
<bean id="calendarA" class="pojo.bstaticFactory" factory-method="getCalendar"></bean>
*/
@Test
public void test03(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
Calendar calendarA=(Calendar) context.getBean("calendarA");
System.out.println(calendarA.getTime());
}
/*
c实例工厂
工厂类
在工厂类中写一个getXXX的非静态方法，返回对象
public Calendar getCalendar(){
return Calendar.getInstance();
}
配置文件中
<bean id="newFactory" class="pojo.bInstanceFactory" ></bean>
<!-- 获取calendar日历对象 factory-bean=上面的bean标签的id factory-method表示实例工厂的方法 -->
<bean id="calendarB" factory-bean="newFactory" factory-method="getCalendar"></bean>
*/
@Test
public void test04(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
Calendar calendarA=(Calendar) context.getBean("calendarB");
System.out.println(calendarA.getTime());
}
/*
d使用spring提供的一个接口 ：FactoryBean<T>
工厂类中实现接口 implements factoryBean<T>
implements FactoryBean<Calendar>{
//获取对象的方法getObject()
@Override
public Calendar getObject() throws Exception {
return Calendar.getInstance();
}
//获取对象的类型
@Override
public Class<?> getObjectType() {
return Calendar.class;
}
//对象是否是单例模式
@Override
public boolean isSingleton() {
return false;
}
}
配置文件中
<bean id="calendarC" class="pojo.bSpingFactory"></bean>
建议：以后需要创建对象时，而该对象又不能直接被spring容器管理，那么我们选择spring提供的工厂模式，FactoryBean
*/
@Test
public void test05(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
Calendar calendarA=(Calendar) context.getBean("calendarC");
System.out.println(calendarA.getTime());
}
/*
a.无参构造，sping默认无参创建对象
配置文件中
<bean id="helloD" class="pojo.aFirstHello"></bean>
*/
@Test
public void test06(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
aFirstHello hello=(aFirstHello) context.getBean("helloD");
hello.say();
}
//---------------------3.判断创建的对象是单例还是多例+懒加载-----------------------------------
/*
----------------知识点3.1: 在spring容器中,默认创建的对象都是单例的---------------------
当applocationContext.xml
<bean id="SingletonUser" class="pojo.cSingletonUser"></bean>
默认输出结果:
我是无参构造
pojo.SingleUser@477a1767
pojo.SingleUser@477a1767
结论:
因为user地址一样，所以在spring容器中,默认创建的对象都是单例的。(单例:在内存中对象有且只有一份)
单例优点:节省内存开销
单例缺点:在一些项目需求中，比如，用户订单模块。订单对象最好是多例，因为单例，对象的内容会更新，看不到之前结果。
-----------------知识点3.2: 在spring容器中,改变创建的对象是多例的---(多例模式的设计)------------------
方式:当applocationContext.xml修改scope属性:
scope="singleton" 默认单例
scope="prototype" 多例，多例默认懒加载
<bean id="SingletonUser" class="pojo.SingletonUser" scope="prototype"></bean>
输出结果：
我是无参构造
pojo.SingletonUser@2c78bc3b
我是无参构造 //懒加载的时候，程序员什么时候调用getBean，spring就什么时候生成对象。
pojo.SingletonUser@2a8ddc4c
知识点3.3
多例模式下：spring不负责对象的生命周期的维护。也就是说，程序员什么时候调用getBean，spring就什么时候生成对象。
单例模式下：spring直接创建出对象，负责对象的生命周期
--------------------知识点3.3 懒加载---------------------------------------------------------------
知识点3.3:对象的懒加载，lazy-init="true"表示懒加载生效，在spring容器启动时不加载，调用时才加载
如果所有的bean都在容器启动时创建,这样会操作性能的降低.
理想:
什么时候需要,什么时候创建 -懒加载
lazy-init="true" //懒加载生效
lazy-init="false" //懒加载不生效
lazy-init="defalut" //默认懒加载配置 根据头标签里面default-lazy-init="true"
注意3.1：如果头标签里面default-lazy-init="true"，下面的lazy-init不用写，使用全局配置
注意3.2：
Lazy-init与scope一起联用时
如果对象是多例的,那么不管lazy-init为啥,统统都是懒加载.
注意3.3:
懒加载和单例/多例没关系，懒加载不会影响输出结果，懒加载只会在spring容器启动时不加载，调用时才加载，
其影响的加载时间，我们看不出来，只能再内存中发现。
*/
@Test
public void test07(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
//获取User对象
cSingletonUser user1=(cSingletonUser) context.getBean("SingletonUser");
System.out.println(user1);
cSingletonUser user2=(cSingletonUser) context.getBean("SingletonUser");
System.out.println(user2);
}
//---------------------------4.spring创建对象的生命周期---------------------------------------
/*
整个spring中对象的简单生命周期划分为4部分
1.对象实例化(构造方法)
2.调用初始化方法
3.对象完成特定的操作
4.对象销毁.
对象类，模拟声明周期
public class dLifeUser {
//构造方法
public dLifeUser(){
System.out.println("无参构造方法");
}
//自定义方法:初始化
public void init(){
System.out.println("初始化方法");
}
//自定义方法:方法调用
public void say(){
System.out.println("对象的方法调用");
}
//自定义方法:销毁
public void destroy(){
System.out.println("对象的销毁");
}
}
配置文件中
init-method="初始化函数" destroy-method="销毁函数" 不用加入构造函数，进行对象实例化
<bean id="user" class="pojo.dLifeUser" init-method="init" destroy-method="destroy"></bean>
输出结果:
无参构造方法
初始化方法
对象的方法调用
2018-8-30 15:15:26 org.springframework.context.support.AbstractApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@423e5d1: startup date [Thu Aug 30 15:15:26 CST 2018]; root of context hierarchy
2018-8-30 15:15:26 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry destroySingletons
信息: Destroying singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@560c3014: defining beans [hello,calendarA,newFactory,calendarB,calendarC,helloD,SingletonUser,user]; root of factory hierarchy
对象的销毁
*/
@Test
public void test08(){
//注意:调用close()方法，必须ApplicationContext改为ClassPathXmlApplicationContext
ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
//获取User对象
dLifeUser user=(dLifeUser) context.getBean("user");
user.say();
context.close(); //关闭sping容器时，sping容器负责的对象全部销毁
}
//---------------------------5.spring的DI（依赖注入）Dependcy Injection -------------------------------------
/*
知识点5：依赖注入:
依赖：谁依赖谁？ user对象的创建，依赖于成员变量。
注入:把谁注入到谁中? 把成员变量的值注入到user对象中
DI的第一种依赖注入的方式：set方式
set方式的原理：根据 setXXX()方法中的，XXX名称来判断的。
1.在bean标签中
<bean id="name" class="pojo.eUserDI">
<property name="name1" value="张三丰"></property>
</bean>
2.spring进行解析时，找name属性，取出其中的值"name1"，然后根据eUserDI类中的setName()方法去匹配
***注意:匹配的规则：把set去掉，然后Name变为小写name。****
3.name1 与 name 匹配，没有成功，所有注入失败
注意:set方式注入，必须要有 对应的 set方法才能够正常的注入
匹配的规则：把set去掉，然后Name变为小写name。
*/
@Test
public void test09(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
//获取User对象
eUserDI user=(eUserDI) context.getBean("UserDI");
System.out.println(user);
}
}
<?xml version="1.0" encoding="UTF-8"?>
<!-- 头文件
xmlns: xml的命名空间\beans
xmlns:xsi:遵循xml的规范
xsi:schemaLocation:xml书写的语法格式
-->
<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-3.2.xsd"
default-lazy-init="true">
<!-- default-lazy-init="true"全局默认懒加载配置 -->
<!-- ************************1.sping的IOC入门*************************** -->
<!-- bean表示sping管理的实体类
id:表示bean标签的唯一标识，不能重复，id的格式:类名首字母小写
class:实体类所在路径，class格式:包名.类名
-->
<bean id="hello" class="pojo.aFirstHello"></bean> <!-- 可以使用alt+/ 快速的定位类-->
<!-- bean标签在重复出现情况下，会报错，比如，项目整合阶段
别名标签:alias
name:引用bean的id的值
alias:程序员根据自己习惯，定义的名称，避免了重复的bean标签出现
-->
<alias name="hello" alias="1806班"></alias>
<!-- ************************2.spring容器创建对象的方式************************** -->
<!-- 2.2静态工厂
factory-method="" 表示 静态工厂中的静态方法
-->
<bean id="calendarA" class="pojo.bstaticFactory" factory-method="getCalendar"></bean>
<!-- 2.3实例工厂
-->
<bean id="newFactory" class="pojo.bInstanceFactory" ></bean>
<!-- 获取calendar日历对象 factory-bean=上面的bean标签的id factory-method表示实例工厂的方法 -->
<bean id="calendarB" factory-bean="newFactory" factory-method="getCalendar"></bean>
<!--
2.4sping提供的FactoryBean
-->
<bean id="calendarC" class="pojo.bSpingFactory"></bean>
<!--
2.1默认无参构造
-->
<bean id="helloD" class="pojo.aFirstHello"></bean>
<!-- **********************3.判断创建的对象是单例还是多例+懒加载************************** -->
<!-- 知识点3.3：
创建的对象是否是多例还是单例，默认是单例
scope="singleton" 默认单例
scope="prototype" 多例，懒加载，什么时候需要,什么时候创建
-->
<!--
知识点3.2:对象的懒加载，lazy-init="true"表示懒加载生效，在spring容器启动时不加载，调用时才加载
如果所有的bean都在容器启动时创建,这样会操作性能的降低.
理想:
什么时候需要,什么时候创建 -懒加载
lazy-init="true" //懒加载生效
lazy-init="false" //懒加载不生效
lazy-init="defalut" //默认懒加载配置 根据头标签里面default-lazy-init="true"
注意3.1：如果头标签里面default-lazy-init="true"，下面的lazy-init不用写，使用全局配置
注意3.2：
Lazy-init与scope一起联用时
如果对象是多例的,那么不管lazy-init为啥,统统都是懒加载.
注意3.3:
懒加载和单例/多例没关系，懒加载不会影响输出结果，懒加载只会在spring容器启动时不加载，调用时才加载，
其影响的加载时间，我们看不出来，只能再内存中发现。
-->
<bean id="SingletonUser" class="pojo.cSingletonUser" scope="prototype" lazy-init="false" ></bean>
<!-- **********************4.spring创建对象的生命周期************************** -->
<!-- 对象的生命周期 初始化和销毁操作
init-method="初始化函数" destroy-method="销毁函数" 不用加入构造函数，进行对象实例化
-->
<bean id="user" class="pojo.dLifeUser" init-method="init" destroy-method="destroy"></bean>
<!-- **********************5.spring的DI（依赖注入）Dependcy Injection************************** -->
<!-- 依赖注入DI set方式的注入
-->
<bean id="UserDI" class="pojo.eUserDI">
<!-- property标签：表示 描类的各个属性
name="" ： 表示 属性名
value="" ：表示 属性值
spring在依赖注入时：自动识别简单的数据类型,如int age 这里value写value="20"而不是value=20
-->
<!-- 1简单类型 -->
<property name="name" value="张三丰"></property>
<property name="age" value="20"></property>
<!-- 2复杂类型 -->
<!-- 2.1 list类型在spring中，默认是ArrayList类型的，arraylist是按数组下标存的 -->
<property name="list">
<list>
<value>1</value>
<value>2</value>
<value>3</value>
</list>
</property>
<!-- 2.2 map类型 -->
<property name="map">
<map>
<entry key="xx" value="西溪"></entry>
<entry key="hz" value="杭州"></entry>
</map>
</property>
<!-- 2.3 set类型 -->
<property name="set">
<set>
<value>1</value>
<value>1</value> <!-- set中元素不可重复，这里只显示一个1 -->
</set>
</property>
<!-- 2.4数组[] list默认是arraylist，arraylist是按数组下标存的，所以可以用list -->
<property name="arr">
<list>
<value>1</value>
<value>2</value>
<value>3</value>
</list>
</property>
<!-- 2.5 Properties类型 -->
<property name="prop">
<props>
<prop key="szh">SHENZHIHENG</prop>
<prop key="szh">sp</prop> <!-- Properties中元素会覆盖，相同key，取后面赋值的值即sp -->
<prop key="WUYUN">wuyun</prop>
</props>
</property>
<!-- 3.引用类型
ref=""引用其他的bean标签，值是bean标签中的
-->
<property name="dog" ref="dog"></property> <!-- 第二步:然后把dog对象注入到User对象中 -->
</bean>
<!-- 描述dog类的对象 ,第一步:Dog类中进行依赖注入，第二步:然后把dog对象注入到User对象中-->
<bean id="dog" class="pojo.eDogRefDI">
<property name="dogName" value="阿旺"></property> <!-- 第一步:Dog类中进行依赖注入 -->
<property name="dogAge" value="12"></property>
</bean>
</beans>
package pojo;
//编写实体类
public class aFirstHello {
//自定义方法
public void say(){
System.out.println("hello spring");
}
/*
//无参构造
public aFirstHello(){
System.out.println("我是无参构造创建对象");
}
//该方法中出现有参构造,则出错
*/
}
package pojo;
import java.util.Calendar;
//静态工厂
public class bstaticFactory {
//自定义方法，静态static修饰
public static Calendar getCalendar(){
return Calendar.getInstance();
}
}
package pojo;
import java.util.Calendar;
//实例工厂
public class bInstanceFactory {
//自定义方法：不使用static
public Calendar getCalendar(){
return Calendar.getInstance();
}
}
package pojo;
import java.util.Calendar;
import org.springframework.beans.factory.FactoryBean;
//sping提供的 implements FactoryBean<T>
public class bSpingFactory implements FactoryBean<Calendar>{
//获取对象的方法getObject()
@Override
public Calendar getObject() throws Exception {
return Calendar.getInstance();
}
//获取对象的类型
@Override
public Class<?> getObjectType() {
return Calendar.class;
}
//对象是否是单例模式
@Override
public boolean isSingleton() {
return false;
}
}
package pojo;
//测试构造的对象是多例还是单例
public class cSingletonUser {
public cSingletonUser(){
System.out.println("我是无参构造");
}
}
package pojo;
//模拟声明周期
public class dLifeUser {
//构造方法
public dLifeUser(){
System.out.println("无参构造方法");
}
//自定义方法:初始化
public void init(){
System.out.println("初始化方法");
}
//自定义方法:方法调用
public void say(){
System.out.println("对象的方法调用");
}
//自定义方法:销毁
public void destroy(){
System.out.println("对象的销毁");
}
}
package pojo;
public class eDogRefDI {
private String dogName;
private int dogAge;
public synchronized String getDogName() {
return dogName;
}
public synchronized void setDogName(String dogName) {
this.dogName = dogName;
}
public synchronized int getDogAge() {
return dogAge;
}
public synchronized void setDogAge(int dogAge) {
this.dogAge = dogAge;
}
@Override
public String toString() {
return "eDogRefDI [dogName=" + dogName + ", dogAge=" + dogAge + "]";
}
}
package pojo;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
//sping的依赖注入DI
/*
依赖：谁依赖谁？ user对象的创建，依赖于成员变量。
注入:把谁注入到谁中? 把成员变量的值注入到user对象中
依赖注入的方式:
1.set方法注入 必须要有set方法
2.构造方法注入
*/
public class eUserDI {
//1.简单类型
private String name;
private int age;
//2.复杂类型
private List list;
private Map map;
private Set set;
private String[] arr;
private Properties prop;
//3.引用类型
private eDogRefDI dog;
public synchronized eDogRefDI getDog() {
return dog;
}
public synchronized void setDog(eDogRefDI dog) {
this.dog = dog;
}
public String getName() {
return name;
}
public void setName(String name) { //如果setName1 name="name1",set方法是根据setXXX方法中，<property name="xxx" ></property>xxx来名称来判断的
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public synchronized Map getMap() {
return map;
}
public synchronized void setMap(Map map) {
this.map = map;
}
public synchronized Set getSet() {
return set;
}
public synchronized void setSet(Set set) {
this.set = set;
}
public synchronized String[] getArr() {
return arr;
}
public synchronized void setArr(String[] arr) {
this.arr = arr;
}
public synchronized Properties getProp() {
return prop;
}
public synchronized void setProp(Properties prop) {
this.prop = prop;
}
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
@Override
public String toString() {
return "UserDI [name=" + name + ", age=" + age + ", list=" + list
+ ", map=" + map + ", set=" + set + ", arr="
+ Arrays.toString(arr) + ", prop=" + prop + ", dog=" + dog
+ "]";
}
}
2.Spring分层模拟 mvc
2.1Servlet
package web;
import pojo.User;
import service.UserService;
//模拟controller层 控制层
public class UserServlet {
//Servlet依赖Service，所以需要使用service对象，接口即可
private UserService userService;
//必须提供service的set方法，因为set方式注入DI，必须要有对应的set方法才能够正常的注入
public void setUserService(UserService userService) {
this.userService = userService;
}
public void addUser(User user){ //添加用户
userService.addUser(user);
}
}
2.2Service
package service;
import pojo.User;
//Service接口
public interface UserService {
//添加用户
public void addUser(User user);
}
package service;
import dao.UserDao;
import pojo.User;
//Service的实现类
public class UserServiceImpl implements UserService {
//service依赖于dao，所以使用dao对象，接口即可
private UserDao userDao;
//必须提供service的set方法，因为set方式注入DI，必须要有对应的set方法才能够正常的注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void addUser(User user) { //添加用户
userDao.addUser(user);
}
}
2.3Dao
package dao;
import pojo.User;
//Dao接口
public interface UserDao {
public void addUser(User user);
}
package dao;
import pojo.User;
//Dao接口实现类
public class UserDaoImpl implements UserDao{
@Override
public void addUser(User user) { //最终操作数据库，实现增加用户的方法
// TODO Auto-generated method stub
System.out.println("新增一个用户："+user);
}
}
2.4Pojo
package pojo;
public class User {
private String name;
private int age;
/*
User类中默认无参构造
配置文件中
<!-- 依赖注入DI 把成员变量的值注入到对象中-->
<bean id="user" class="pojo.User">
<property name="name" value="szh"></property> <!-- 简单类型的注入： 把成员变量的值注入到对象中 -->
<property name="age" value="20"></property>
</bean>
*/
/*
User类中有参构造方法
配置文件中
<!-- 有参构造方法注入,和 <constructor-arg>标签 配套
index=有参构造方法第几个参数
name=set方法，去set，第一个字母小写
value=对应属性的值
-->
<constructor-arg index="0" name="name" value="hehe"></constructor-arg>
<constructor-arg index="1" name="age" value="10"></constructor-arg>
*/
public User(String name,int age) {
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
public synchronized String getName() {
return name;
}
public synchronized void setName(String name) {
this.name = name;
}
public synchronized int getAge() {
return age;
}
public synchronized void setAge(int age) {
this.age = age;
}
}
2.5配置文件applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- 头文件
xmlns: xml的命名空间\beans
xmlns:xsi:遵循xml的规范
xsi:schemaLocation:xml书写的语法格式
-->
<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-3.2.xsd"
>
<!-- 依赖注入DI 把成员变量的值注入到对象中-->
<bean id="user" class="pojo.User">
<!--1.1无参构造方法注入,和<property>标签配套
<property name="name" value="szh"></property> 简单类型的注入： 把成员变量的值注入到对象中
<property name="age" value="20"></property>
-->
<!--1.2有参构造方法注入,和 <constructor-arg>标签 配套
index=有参构造方法第几个参数
name=set方法，去set，第一个字母小写
value=对应属性的值
-->
<constructor-arg index="0" name="name" value="hehe"></constructor-arg>
<constructor-arg index="1" name="age" value="10"></constructor-arg>
</bean>
<bean id="userDao" class="dao.UserDaoImpl"> </bean> <!-- bean表示sping管理的实体类 -->
<bean id="userService" class="service.UserServiceImpl">
<property name="userDao" ref="userDao"></property> <!-- 引用类型的注入:(引用类型:类中还有其他类对象) userServiceImpl类中有userDao接口对象
name set方法，即service.UserServiceImpl的setUserDao()方法中，去set，第一个字母小写
ref 引用其他的bean标签的id,即<bean id="userDao"><bean> -->
</bean>
<bean id="userServlet" class="web.UserServlet">
<property name="userService" ref="userService"></property> <!-- 引用类型的注入:(引用类型:类中还有其他类对象) userServlet类中有userService接口对象
name set方法的注入，即service.UserServlet的setUserService()方法中，去set，第一个字母小写
ref 引用其他的bean标签的id，即<bean id="userService"><bean> -->
</bean>
</beans>
2.6测试类
package Test;
import java.util.Calendar;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.User;
import web.UserServlet;
//进行单元测试类
public class TestSping {
@Test
public void test01(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
//客户端Servlet
UserServlet userServlet=(UserServlet) context.getBean("userServlet");
//获取用户对象
User user=(User) context.getBean("user");
//添加一个用户
userServlet.addUser(user);
}
}
320
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
