一,采用注入方式建立对象关系,Dependency Injection (DI)依赖注入
1,依赖注入:set方法的注入
在Java project Package1包内,新建Computer类,获取get ,set方法
package Package1;
public class Computer {
private String cpu;
private String hdd;
private String mainbord;
public void show(){
System.out.println("cpu:"+cpu);
System.out.println("hdd:"+hdd);
System.out.println("mainbord:"+mainbord);
}
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public String getHdd() {
return hdd;
}
public void setHdd(String hdd) {
this.hdd = hdd;
}
public String getMainbord() {
return mainbord;
}
public void setMainbord(String mainbord) {
this.mainbord = mainbord;
}
}
在applicationContext.xml中加入<bean>标签,
<bean id="a1" class="Package1.Computer" >
<!--信息set注入 -->
<property name="cpu" value="骁龙"> </property>
<property name="hdd" value="索尼"> </property>
<property name="mainbord" value="华硕"> </property>
</bean>
在测试类中,我们可以通过
public static void main(String[] args) {
//原方法 Computer com=new Computer();
// com.setCpu("i7");
// com.setHdd("希捷");
// com.setMainbord("hh");
String conf="applicationContext.xml";
ApplicationContext ac=new ClassPathXmlApplicationContext(conf);
Computer c= ac.getBean("a1",Computer.class);
2.依赖注入:构造器注入
在Java project Package1包内,新建Phone类,写出构造方法
package Package1;
public class Phone {
private String cpu;
private String ram;
public Phone(String cpu,String ram ){
this.cpu=cpu;
this.ram=ram;
}
public void show(){
System.out.println("cpu:"+cpu);
System.out.println("ram:"+ram);
}
}
在applicationContext.xml中加入<bean>标签,
<bean id="b1" class="Package1.Phone" >
<!--构造器注入 -->
<constructor-arg index="0" value="高通"></constructor-arg>
<constructor-arg index="1" value="4G"></constructor-arg>
</bean>
在测试类main方法中
public static void main(String[] args) {
String conf="ApplicationContext.xml";
ApplicationContext ac=new ClassPathXmlApplicationContext(conf);
Phone phone=ac.getBean("b1",Phone.class);
phone.show();
}
3.set注入 自定义类对象
在Java project Package1包内,新建Student类,写出get set方法
package Package1;
public class Student {
private Computer c;
private Phone p;
public void show()
{
c.show();
p.show();
}
public Computer getC() {
return c;
}
public void setC(Computer c) {
this.c = c;
}
public Phone getP() {
return p;
}
public void setP(Phone p) {
this.p = p;
}
}
在applicationContext.xml中加入<bean>标签,
<bean id="s1" class="Package1.Student" >
<!--信息set注入Computer nama="student类的对象名" ref=“引用的id名” -->
<property name="c" ref ="a1"> </property>
<!--信息set注入Phone ref -->
<property name="p" ref="b1"> </property>
</bean>
在测试类main方法中
public static void main(String[] args) {
String conf="applicationContext.xml";
ApplicationContext ac=new ClassPathXmlApplicationContext(conf);
Student student=ac.getBean("s1",Student.class);
student.show();
}
4.自动注入
在applicationContext.xml中加入<bean>标签,这里有byType,byName,constructor等用于简化注入配置,使用byType需注意,有两个及以上的同类型时匹配会出异常。
<bean autowire="default"></bean>
二,各种类型信息的注入配置格式
1,注入字符串,数值单个数值
<bean id="d1" class="Package2.MessageBean" >
<!--信息set注入 -->
<property name="name" value="wjc"> </property>
<!-- 18会自动转换为int -->
<property name="age" value="18"> </property>
<!-- 注入 系统无法自己搞成date 需要我们在set中自己转换 -->
<property name="birth" value="1998-06-13"> </property></bean>
2,注入bean对象(用ref)
3,注入list,set,map,properties
在applicationContext.xml中加入<bean>标签
<property name="friends" >
<list>
<value>tom</value>
<value>rose</value>
<value>jack</value>
<value>Amy</value>
</list>
</property>
<property name="cities">
<set>
<value>北京</value>
<value>上海</value>
</set>
</property>
<property name="books">
<map>
<entry key="钢铁是怎样炼成的" value="保尔柯察金"></entry>
<entry key="茶馆" value="老舍"></entry>
</map>
</property>
<property name="db">
<props>
<prop key="username">root</prop>
<prop key="password">1234</prop>
<prop key="driver">com.mysql.jdbc.Driver</prop>
</props>
</property>
4.Spring表达式的注入
(1)在applicationContext.xml中bean>标签外加入 list,set,map,properties,方便多次使用
<!-- 定义List<String>对象 -->
<util:list id="someList">
<value>林殊</value>
<value>靖王</value>
<value>郡主</value>
</util:list>
<util:set id="someSet">
<value>浙江</value>
<value>福建</value>
<value>台湾</value>
</util:set>
<util:map id="someMap">
<entry key="祥林嫂" value="鲁迅"></entry>
<entry key="朝花夕拾" value="鲁迅"></entry>
</util:map>
<!-- 在bean外形成一个Properties对象 ,方便多次调用 -->
<util:properties id="someProp">
<prop key="username">root1</prop>
<prop key="password">123456</prop>
<prop key="driver">com.mysql.jdbc.Driver</prop>
</util:properties>
(2)在xml文件外,新建一个db.properties文件
# key=value
user=root1
password=1234
driver=com.mysql.jdbc,Driver
url=jdbc\:mysql\://localhost\:3306/test
在application中我们通过
<!-- 读取db.properties文件,形成一个Properties对象 常用于数据库 -->
<util:properties id="dbParams" location="classpath:db.properties">
</util:properties>
然后在其他表达式中能用到该文件的内容:
#{表达式},
#{id名.属性}或#{id名.key}
如果是对象属性,需要有getxxx方法
<!-- 利用#{表达式}提取dbParams对象信息 -->
<util:properties id="someprop1">
<prop key="username">#{dbParams.user}</prop>
<prop key="password">#{dbParams.password}</prop>
<prop key="driver">#{dbParams.driver}</prop>
</util:properties>
运用:
<bean id="msg1" class="Package2.MessageBean">
<!-- 只调用外部文件的一部分内容 -->
<!--<property name="name" value="{dbParams.user}"></property> -->
<!--通过id 调用另一个bean的 name对象 -->
<!-- <property name="name" value="#{msg2.name}"></property> -->
<property name="friends" ref="someList"></property>
<property name="cities" ref="someSet"></property>
<property name="books" ref="someMap"></property>
<property name="db" ref="dbParams"></property>
</bean>
* 新建Package2中新建类MessageBean
package Package2;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
public class MessageBean {
private String name;
private int age;
//涉及转换string --》date
private Date birth;
private List<String> friends;
private Set<String> cities;
private Map<String, String> books;
private Properties db;
public Properties getDb() {
return db;
}
public void setDb(Properties db) {
this.db = db;
}
public Map<String, String> getBooks() {
return books;
}
public void setBooks(Map<String, String> books) {
this.books = books;
}
public Set<String> getCities() {
return cities;
}
public void setCities(Set<String> cities) {
this.cities = cities;
}
public List<String> getFriends() {
return friends;
}
public void setFriends(List<String> friends) {
this.friends = friends;
}
public Date getBirth() {
return birth;
}
public void setBirth(String birth) {
Date date = null;
try {
date = new SimpleDateFormat("yyyy-MM-dd").parse(birth);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.birth =date;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void show(){
System.out.println("name:"+name+",age:"+age+",birth:"+birth);
for(String s:friends)
System.out.println("my friends are"+s);
for(String c:cities)
System.out.println("my cities are"+c);
Set<Entry<String,String>> booksset= books.entrySet();
for( Entry<String, String> s: booksset){
System.out.println("书名:《"+s.getKey()+"》 "+"作者:"+s.getValue());
}
Set<Object> keys=db.keySet();
for(Object key :keys){
//用key获取 value信息 在标签中间
System.out.println(key+":"+db.getProperty(key.toString()));
}
}
}
* IOC概念:控制反转,改变了对象获取的方式:
以前是,编码方式,采用new构造器方式来获取对象;
IOC中采用由容器创建对象之后注入来使用