Spring我爱编程

01_Spring

2017-05-06  本文已影响66人  对方不想理你并向你抛出一个异常

今天内容概述

  1. Spring框架的概述
  2. SpringIOC的快速入门
  3. IoC容器XML的方式
  4. 在web项目中集成Spring

案例一：使用Spring的IOC技术完成客户的保存功能

需求分析

  1. 使用Spring的IOC技术完成客户的保存功能

技术分析之Spring框架的概述和入门

技术分析之什么是Spring框架
1， Spring框架的概述

技术分析之Spring框架的特点
1， 为什么要学习Spring的框架

2， Spring框架的版本

技术分析之Spring框架的IOC核心功能快速入门
1， 什么是IOC的功能？

2， 步骤一：下载Spring框架的开发包

3， 步骤二：创建JavaWEB项目，引入Spring的开发包

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'debug' ###
log4j.rootLogger=info, stdout

public class Demo1 {
    private Logger log = Logger.getLogger(Demo1.class);
    @Test
    public void Test()
    {
        System.out.println("执行。。。");
        log.info("执行。。。");
    }
}

4， 步骤三：创建对应的包结构，编写Java的类，要注意：以后使用Spring框架做开发，都需要来编写接口与实现类！！

package com.huachao.demo2;
public interface UserService {
    public void sayHello();
}

package com.huachao.demo2;
public class UserServiceImp implements UserService {
    @Override
    public void sayHello() {
        System.out.println("Hello Spring");
    }
}

5， 步骤四：想把UserServiceImpl实现类的创建交给Spring框架来管理，需要创建Spring框架的配置文件，完成配置

<?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">
    <!-- id是自己起的 -->
    <bean id="userService" class="com.huachao.demo2.UserServiceImp"/>
</beans>

6， 步骤五：编写测试程序，采用Spring框架的工厂方式来获取到UserService接口的具体实现类！！


    @Test
    public void Run1()
    {
//        UserServiceImp us = new UserServiceImp();
        UserService us = new UserServiceImp();
        us.sayHello();
    }
    @Test
    public void Run2()
    {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //userService为bean标签的id
//        UserServiceImp us = (UserServiceImp) ac.getBean("userService");
        UserService us = (UserService) ac.getBean("userService");
        us.sayHello();
    }

入门总结之Spring框架中的工厂（了解）
1， ApplicationContext接口

2， BeanFactory工厂（是Spring框架早期的创建Bean对象的工厂接口）

 public void run(){
 BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
 UserService us = (UserService) factory.getBean("us");
 us.sayHello();
 }

入门总结之配置Spring框架编写XML的提示

  1. 步骤一：先复制， http://www.springframework.org/schema/beans/spring-beans.xsd
  2. 步骤二：打开Windows->Preferences，搜索XML Catalog，点击Add按钮
  3. 步骤三：先选择Location的schema的约束地址
  1. 步骤四：注意：Key type要选择：Schema location（这一步和之前不一样，之前选择的是URI）
  2. 步骤五：Key把http://www.springframework.org/schema/beans/spring-beans.xsd复制上

技术分析之Spring框架的Bean管理的配置文件方式

技术分析之Spring框架中<bean>标签的配置
1， id属性和name属性的区别

2， class属性　　　　　-- Bean对象的全路径
3， scope属性　　　　　-- scope属性代表Bean的作用范围

4， Bean对象的创建和销毁的两个属性配置（了解）

例：演示init-method和destroy-method
UserServiceImp.java

package com.huachao.demo2;
public class UserServiceImp implements UserService {
    @Override
    public void sayHello() {
        System.out.println("Hello Spring");
    }
    public void init() {
        System.out.println("init....");
    }
    public void destory() {
        System.out.println("destory....");
    }
}

applicationContext.xml的bean配置

<bean id="userService" class="com.huachao.demo2.UserServiceImp" init-method="init" destroy-method="destory"/>

测试代码


    /**
     * 演示调用销毁方法
     */
    @Test
    public void Run3()
    {
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //userService为bean标签的id
//        UserServiceImp us = (UserServiceImp) ac.getBean("userService");
        UserService us = (UserService) ac.getBean("userService");
        us.sayHello();
        ac.close();
    }

技术分析之依赖注入（DI）

  1. IOC和DI的概念
  1. DI（依赖注入）
public class UserServiceImp implements UserService {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void sayHello() {
        System.out.println("Hello Spring,"+name);
    }
    public void init() {
        System.out.println("init....");
    }
    public void destory() {
        System.out.println("destory....");
    }
}

    <bean id="userService" class="com.huachao.demo2.UserServiceImp">
        <property name="name" value="美美"/>
    </bean>

例：注入对象
CustomerDao.java

package com.huachao.demo3;
public class CustomerDao {
    public void save()
    {
        System.out.println("Dao 的保存。。。");
    }
}

CustomerService.java

package com.huachao.demo3;
public class CustomerService {
    private CustomerDao customerDao;
    public void setCustomerDao(CustomerDao customerDao) {
        this.customerDao = customerDao;
    }

    public void save()
    {
        System.out.println("Service 的保存。。。");
        customerDao.save();
    }
}

applicationContext.xml配置的bean


    <bean id="customerDao" class="com.huachao.demo3.CustomerDao"/>
    <bean id="customerService" class="com.huachao.demo3.CustomerService">
        <property name="customerDao" ref="customerDao"/>
    </bean>

测试代码

@Test
    public void Run1()
    {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        CustomerService cs = (CustomerService) ac.getBean("customerService");
        cs.save();
    }

技术分析之Spring框架的属性注入
1，对于类成员变量，常用的注入方式有两种

2，在Spring框架中提供了前两种的属性注入的方式
①构造方法的注入方式，两步

 public class Car {
 private String name;
 private double money;
 public Car(String name, double money) {
 this.name = name;
 this.money = money;
 }
 @Override
 public String toString() {
 return "Car [name=" + name + ", money=" + money + "]";
 }
 }

 <bean id="car" class="com.itheima.demo4.Car">
 <constructor-arg name="name" value="大奔"/>
 <constructor-arg name="money" value="100"/>
 </bean>

② 属性的setter方法的注入方式

③如果Java类的属性是另一个Java的类，那么需要怎么来注入值呢？

 <bean id="person" class="com.itheima.demo4.Person">
 <property name="pname" value="美美"/>
 <property name="car2" ref="car2"/>
 </bean>

例：构造函数注入和setter方法注入
car实例类，有带参数的构造函数

package com.huachao.demo4;
public class Car {
    private String cname;
    private Integer price;
    public Car(String cname, Integer price) {
        this.cname = cname;
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car [cname=" + cname + ", price=" + price + "]";
    }
}

person实例类，有属性的setter方法

package com.huachao.demo4;
public class Person {
    private String pname;
    private Car car;
    public String getPname() {
        return pname;
    }
    public void setPname(String pname) {
        this.pname = pname;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    @Override
    public String toString() {
        return "Person [pname=" + pname + ", car=" + car + "]";
    }
}

applicationContext.xml中bean的注册

    <bean id="car" class="com.huachao.demo4.Car">
        <!-- <constructor-arg name="cname" value="马自达"/>
        <constructor-arg name="price" value="25000"/> -->
        <constructor-arg index="0" value="马自达"/>
        <constructor-arg index="1" value="25000"/>
    </bean>
    <bean id="person" class="com.huachao.demo4.Person">
        <property name="pname" value="小小"/>
        <property name="car" ref="car"/>
    </bean>

测试代码

@Test
    public void Run1()
    {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person =  (Person) ac.getBean("person");
        System.out.println(person.toString());
    }

技术分析之Spring的2.5版本中提供了一种:p名称空间的注入（了解）

  1. 步骤一：需要先引入 p 名称空间
  1. 步骤二：使用p名称空间的语法
  1. 步骤三：测试

技术分析之Spring的3.0提供了一种:SpEL注入方式（了解）
1， SpEL：Spring Expression Language是Spring的表达式语言，有一些自己的语法
2， 语法

3， 例如如下的代码

 <!-- SpEL的方式 -->
 <bean id="person" class="com.itheima.demo4.Person">
 <property name="pname" value="#{'小风'}"/>
 <property name="car2" value="#{car2}"/>
 </bean>

<font color=red>注意：</font>详细用法参考Spring_表达式语言.pdf

4， 还支持调用类中的属性或者方法

 public class CarInfo {
 public String getCarname(){
 return "奇瑞QQ";
 }
 }

例：P名称空间注入
Car2实例类，有setter方法

package com.huachao.demo4;
public class Car2 {
    private String cname;
    private Integer price;
    public void setCname(String cname) {
        this.cname = cname;
    }
    public void setPrice(Integer price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car2 [cname=" + cname + ", price=" + price + "]";
    }
}

applicationContext.xml中beans标签是添加xmlns:p="http://www.springframework.org/schema/p"

<?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:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd">

applicationContext.xml中添加bean

<bean id="car2" class="com.huachao.demo4.Car2" p:cname="长安福特" p:price="28000"/>

测试代码


    @Test
    public void Run2()
    {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Car2 c2 =  (Car2) ac.getBean("car2");
        System.out.println(c2.toString());
    }

例：SpEL表达式注入
使用SpEL表达式表达式注入上例的Car2，xmlns:p="http://www.springframework.org/schema/p"不需要可以删除
applicationContext.xml中bean如下


    <bean id="car2" class="com.huachao.demo4.Car2">
        <property name="cname" value="#{'宝马'}"/>
        <property name="price" value="#{320000}"/>
    </bean>

技术分析之数组，集合(List,Set,Map)，Properties等的注入
1， 如果是数组或者List集合，注入配置文件的方式是一样的

 <bean id="collectionBean" class="com.itheima.demo5.CollectionBean">
 <property name="arrs">
 <list>
 <value>美美</value>
 <value>小风</value>
 </list>
 </property>
 </bean>

2， 如果是Set集合，注入的配置文件方式如下：

 <property name="sets">
 <set>
 <value>哈哈</value>
 <value>呵呵</value>
 </set>
 </property>

3， 如果是Map集合，注入的配置方式如下：

 <property name="map">
 <map>
 <entry key="老王2" value="38"/>
 <entry key="凤姐" value="38"/>
 <entry key="如花" value="29"/>
 </map>
 </property>

4， 如果是properties属性文件的方式，注入的配置如下：

 <property name="pro">
 <props>
 <prop key="uname">root</prop>
 <prop key="pass">123</prop>
 </props>
 </property>

例：注入集合
User实例类中有各种集合，已经提供setter方法

package com.huachao.demo5;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class User {
    private String[] arr;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties pro;
    public void setArr(String[] arr) {
        this.arr = arr;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setSet(Set<String> set) {
        this.set = set;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    public void setPro(Properties pro) {
        this.pro = pro;
    }
    @Override
    public String toString() {
        return "User [arr=" + Arrays.toString(arr) + ", list=" + list + ", set=" + set + ", map=" + map + ", pro=" + pro
                + "]";
    }
}

applicationContext.xml中注入User的bean如下

<bean id="user" class="com.huachao.demo5.User">
        <property name="arr">
            <list>
                <value>数组元素1</value>
                <value>数组元素2</value>
            </list>
        </property>
        <property name="list">
            <list>
                <value>list元素1</value>
                <value>list元素2</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>set元素1</value>
                <value>set元素2</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="key1" value="map的value1"/>
                <entry key="key2" value="map的value2"/>
            </map>
        </property>
        <property name="pro">
            <props>
                <prop key="Properties key1">Properties value1</prop>
                <prop key="Properties key2">Properties value2</prop>
            </props>
        </property>
    </bean>

技术分析之Spring框架的配置文件分开管理（了解）
1， 例如：在src的目录下又多创建了一个配置文件，现在是两个核心的配置文件，那么加载这两个配置文件的方式有两种！

Spring框架整合WEB

Spring框架整合WEB（不是最终的方案）
1， 创建JavaWEB项目，引入Spring的开发包。编写具体的类和方法。

2， 解决上面的问题

3， Spring整合Web项目

  <!-- 配置Spring的核心监听器: -->
  <listener>
   <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

4， 修改servlet的代码

 ServletContext servletContext = ServletActionContext.getServletContext();
 // 需要使用WEB的工厂的方式
 WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servletContext);
 CustomerService cs = (CustomerService) context.getBean("customerService");
 cs.save();

注意：
1，主要用于解决struts2和spring整合的过程中，在Action中获取Spring的工厂对象，不用每次都加载资源。
2，具体代码参考day35_crm

上一篇下一篇

猜你喜欢

热点阅读