zoukankan      html  css  js  c++  java
  • Spring-Lesson1

    spring介绍

    三层架构中spring位置

    spring一站式框架(正是因为spring框架性质是属于容器性质的.)

    容器中装什么对象就有什么功能.所以可以一站式.

    不仅不排斥其他框架,还能帮其他框架管理对象.

    aop支持

    ioc思想

    spring jdbc

    aop 事务

    junit 测试支持


    spring搭建

    1.导包

    spring-beans-4.2.4.RELEASE.jar
    spring-context-4.2.4.RELEASE.jar
    spring-core-4.2.4.RELEASE.jar
    spring-expression-4.2.4.RELEASE.jar
    com.springsource.org.apache.commons.logging-1.1.1.jar
    com.springsource.org.apache.log4j-1.2.15.jar(老版本需要)

    2.创建一个对象

    package cn.itcast.bean;
    
    public class User {
        
        public User() {
                System.out.println("User对象空参构造方法!!!!");
        }
    private String name; private Integer age; private Car car; public User(String name, Car car) { System.out.println("User(String name, Car car)!!"); this.name = name; this.car = car; } public User(Car car,String name) { System.out.println("User(Car car,String name)!!"); this.name = name; this.car = car; } public User(Integer name, Car car) { System.out.println("User(Integer name, Car car)!!"); this.name = name+""; this.car = car; } public Car getCar() { return car; } public void setCar(Car car) { this.car = car; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public void init(){ System.out.println("我是初始化方法!"); } public void destory(){ System.out.println("我是销毁方法!"); } @Override public String toString() { return "User [name=" + name + ", age=" + age + ", car=" + car + "]"; } }

    3.书写配置注册对象到容器

    位置任意(建议放到src下)
    配置文件名任意(建议applicationContext.xml)

    导入约束

    windows-->preferences-->搜索cata

    新建xml配置文件,写上<beans></beans>

    <!-- 将User对象交给spring容器管理 -->
    <!-- Bean元素:使用该元素描述需要spring容器管理的对象
            class属性:被管理对象的完整类名.
            name属性:给被管理的对象起个名字.获得对象时根据该名称获得对象.  
                    可以重复.可以使用特殊字符.
            id属性: 与name属性一模一样. 
                    名称不可重复.不能使用特殊字符.
            结论: 尽量使用name属性.
      -->
    <bean  name="user" class="cn.itcast.bean.User" ></bean>

     4.代码测试

    @Test
    public void fun1(){
        
        //1 创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 向容器"要"user对象
        User u = (User) ac.getBean("user");
        //3 打印user对象
        System.out.println(u);
        
    }

    spring概念

    思想

    ioc

    di

    applicationContext&BeanFactory

    BeanFactory接口

    spring原始接口.针对原始接口的实现类功能较为单一

    BeanFactory接口实现类的容器.特点是每次在获得对象时才会创建对象

    ApplicationContext

    每次容器启动时就会创建容器中配置的所有对象.并提供更多功能

    从类路径下加载配置文件:ClassPathXmlApplicationContext

    从硬盘绝对路径下加载配置文件:FileSystemXmlApplicationContext("d:/xxx/yyy/xxx")

    结论:web开发中,使用applicationContext. 在资源匮乏的环境可以使用BeanFactory.


    Spring配置详解

    Spring创建对象的三种方式

    准备工作

    package cn.itcast.b_create;
    
    import cn.itcast.bean.User;
    
    public class UserFactory {
    
        public static User createUser(){
            System.out.println("静态工厂创建User");
            return new User();
        }
        
        public  User createUser2(){
            System.out.println("实例工厂创建User");
            return new User();
        }
    }

    配置方式

    <!-- 创建方式1:空参构造创建  -->
    <bean  name="user" class="cn.itcast.bean.User" init-method="init" destroy-method="destory" ></bean>
         
    <!-- 创建方式2:静态工厂创建 
          调用UserFactory的createUser方法创建名为user2的对象.放入容器
     -->
    <bean  name="user2" class="cn.itcast.b_create.UserFactory" factory-method="createUser" ></bean>
        
    <!-- 创建方式3:实例工厂创建 
         调用UserFactory对象的createUser2方法创建名为user3的对象.放入容器
     -->
    <bean  name="user3" factory-bean="userFactory" factory-method="createUser2" ></bean>
    <bean  name="userFactory" class="cn.itcast.b_create.UserFactory"   ></bean>

    测试

    @Test
    // 创建方式1:空参构造
    public void fun1() {
        // 1 创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/b_create/applicationContext.xml");
        // 2 向容器"要"user对象
        User u = (User) ac.getBean("user");
    
        // 3 打印user对象
        System.out.println(u);
    }
    
    // 创建方式2:静态工厂
    @Test
    public void fun2() {
        // 1 创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/b_create/applicationContext.xml");
        // 2 向容器"要"user对象
        User u = (User) ac.getBean("user2");
        // 3 打印user对象
        System.out.println(u);
    }
    
    // 创建方式3:实例工厂
    @Test
    public void fun3() {
        // 1 创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/b_create/applicationContext.xml");
        // 2 向容器"要"user对象
        User u = (User) ac.getBean("user3");
        // 3 打印user对象
        System.out.println(u);
    }

    spring的分模块配置

    <!-- 导入其他spring配置文件 -->
    <import resource="cn/itcast/b_create/applicationContext.xml"/>

    Bean元素进阶

    scope属性

    singleton(默认值):单例对象.被标识为单例的对象在spring容器中只会存在一个实例

    prototype:多例原型.被标识为多例的对象,每次再获得才会创建.每次创建都是新的对象.整合struts2时,ActionBean必须配置为多例的.

    <bean  name="user" class="cn.itcast.bean.User" scope="prototype" ></bean>

    效果

    @Test
    // scope:singleton 单例
    // scope:prototype 多例
    public void fun4() {
        // 1 创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext(
                "cn/itcast/b_create/applicationContext.xml");
        // 2 向容器"要"user对象
        User u = (User) ac.getBean("user");
        User u2 = (User) ac.getBean("user");
        User u3 = (User) ac.getBean("user");
        User u4 = (User) ac.getBean("user");
    
        System.out.println(u2 == u4);// 单例:true
                                        // 多例:false
        // 3 打印user对象
        System.out.println(u);
    }

    request:web环境下.对象与request生命周期一致.

    session:web环境下,对象与session生命周期一致.


    生命周期属性

    init-method

    配置一个方法作为生命周期初始化方法.spring会在对象创建之后立即调用.

    destory-method

    配置一个方法作为生命周期的销毁方法.spring容器在关闭并销毁所有容器中的对象之前调用.

    <bean  name="user" class="cn.itcast.bean.User" init-method="init" destroy-method="destory" ></bean>

    User类新建方法

    public void init(){
        System.out.println("我是初始化方法!");
    }
    public void destory(){
        System.out.println("我是销毁方法!");
    }

    测试

    @Test
    // 测试生命周期方法
    public void fun5() {
        // 1 创建容器对象
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext(
                "cn/itcast/b_create/applicationContext.xml");
        // 2 向容器"要"user对象
        User u = (User) ac.getBean("user");
        // 3 打印user对象
        System.out.println(u);
        // 关闭容器,触发销毁方法
        ac.close();
    }

    Spring属性注入方式

    set方法注入

    <!-- set方式注入: -->
    <bean  name="user" class="cn.itcast.bean.User" >
        <!--值类型注入: 为User对象中名为name的属性注入tom作为值 -->
        <property name="name" value="tom" ></property>
        <property name="age"  value="18" ></property>
        <!-- 引用类型注入: 为car属性注入下方配置的car对象 -->
        <property name="car"  ref="car" ></property>
    </bean>
    
    <!-- 将car对象配置到容器中 -->
    <bean name="car" class="cn.itcast.bean.Car" >
        <property name="name" value="兰博基尼" ></property>
        <property name="color" value="黄色" ></property>
    </bean>

    测试

    @Test
    public void fun1(){
        //1 创建容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/c_injection/applicationContext.xml");
        //2 向容器"要"user对象
        User u = (User) ac.getBean("user或user2或user3或user4");
        //3 打印user对象
        System.out.println(u);
    }

    构造函数注入

    不管你的构造函数千奇百怪

    <!-- 构造函数注入 -->
    <bean name="user2" class="cn.itcast.bean.User" >
        <!-- name属性: 构造函数的参数名 -->
        <!-- index属性: 构造函数的参数索引 -->
        <!-- type属性: 构造函数的参数类型-->
        <constructor-arg name="name" index="0" type="java.lang.Integer" value="999"  ></constructor-arg>
        <constructor-arg name="car" ref="car" index="1" ></constructor-arg>
    </bean>

    p名称空间注入

    <!-- p名称空间注入, 走set方法
        1.导入P名称空间  xmlns:p="http://www.springframework.org/schema/p"
        2.使用p:属性完成注入
            |-值类型: p:属性名="值"
            |-对象类型: p:属性名-ref="bean名称"
     -->
    <bean  name="user3" class="cn.itcast.bean.User" p:name="jack" p:age="20" p:car-ref="car"  >
    </bean>

    spel注入

    <!-- 
        spel注入: spring Expression Language sping表达式语言
     -->
    <bean  name="user4" class="cn.itcast.bean.User" >
        <property name="name" value="#{user.name}" ></property>
        <property name="age" value="#{user3.age}" ></property>
        <property name="car" ref="car" ></property>
    </bean>

    复杂类型注入

    准备

    package cn.itcast.c_injection;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    import java.util.Properties;
    
    public class CollectionBean {
        private Object[] arr;//数组类型注入
        private List list;//list/set 类型注入
        private Map map;//map类型注入
        private Properties prop;//properties类型注入
        
        public Object[] getArr() {
            return arr;
        }
        public void setArr(Object[] arr) {
            this.arr = arr;
        }
        public List getList() {
            return list;
        }
        public void setList(List list) {
            this.list = list;
        }
        public Map getMap() {
            return map;
        }
        public void setMap(Map map) {
            this.map = map;
        }
        public Properties getProp() {
            return prop;
        }
        public void setProp(Properties prop) {
            this.prop = prop;
        }
        @Override
        public String toString() {
            return "CollectionBean [arr=" + Arrays.toString(arr) + ", list=" + list + ", map=" + map + ", prop=" + prop
                    + "]";
        }
    }

    复杂类型注入写法

    <!-- 复杂类型注入 -->
    <bean name="cb" class="cn.itcast.c_injection.CollectionBean" >
        <!-- 如果数组中只准备注入一个值(对象),直接使用value|ref即可 
        <property name="arr" value="tom" ></property>
        -->
        <!-- array注入,多个元素注入 -->
        <property name="arr">
            <array>
                <value>tom</value>
                <value>jerry</value>
                <ref bean="user4" />
            </array>
        </property>
        
        <!-- 如果List中只准备注入一个值(对象),直接使用value|ref即可 
        <property name="list" value="jack" ></property>-->
        <property name="list"  >
            <list>
                <value>jack</value>
                <value>rose</value>
                <ref bean="user3" />
            </list>
        </property>
        <!-- map类型注入 -->
        <property name="map"  >
            <map>
                <entry key="url" value="jdbc:mysql:///crm" ></entry>
                <entry key="user" value-ref="user4"  ></entry>
                <entry key-ref="user3" value-ref="user2"  ></entry>
            </map> 
        </property>
        <!-- prperties 类型注入 -->
        <property name="prop"  >
            <props>
                <prop key="driverClass">com.jdbc.mysql.Driver</prop>
                <prop key="userName">root</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>

    练习:将spring容器应用到struts-crm项目

    https://github.com/ChenCurry/test_struts2/tree/develop

    (还算不上SSH框架整合,仅仅是进行改造,使用其管理对象的功能)

    管理Service对象以及Dao对象

    1.导包(4+2),再加1

    spring-web-4.2.4.RELEASE.jar

    2.将Service对象以及Dao对象配置到spring容器

    在需要使用Dao对象的ServiceImpl中设置相应的set方法

    <!-- 配置Dao -->
    <bean name="customerDao" class="cn.itheima.dao.impl.CustomerDaoImpl" ></bean>
    <bean name="linkManDao" class="cn.itheima.dao.impl.LinkManDaoImpl" ></bean>
    <bean name="userDao" class="cn.itheima.dao.impl.UserDaoImpl" ></bean>
    <!-- 配置Service -->
    <bean name="customerService" class="cn.itheima.service.impl.CustomerServiceImpl" >
        <property name="customerDao" ref="customerDao" ></property>
    </bean>
    <bean name="linkManService" class="cn.itheima.service.impl.LinkManServiceImpl" >
        <property name="cd" ref="customerDao" ></property>
        <property name="lmd" ref="linkManDao" ></property>
    </bean>
    <bean name="userService" class="cn.itheima.service.impl.UserServiceImpl" >
        <property name="ud" ref="userDao" ></property>
    </bean>

     3.在Action中获得容器中的Service对象

    //获得spring容器=>从Application域获得即可
    
    //1 获得servletContext对象
    ServletContext sc = ServletActionContext.getServletContext();
    //2.从Sc中获得ac容器
    WebApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(sc);
    //3.从容器中获得CustomerService
    CustomerService cs = (CustomerService) ac.getBean("customerService");

    web.xml中配置容器随项目启动

      <!-- 可以让spring容器随项目的启动而创建,随项目的关闭而销毁 -->
      <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <!-- 指定加载spring配置文件的位置 -->
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
      </context-param>
    击石乃有火,不击元无烟!!
  • 相关阅读:
    013.ES6 -对象字面量增强型写法
    012. ES6
    011. ES6 语法
    10. 9. Vue 计算属性的setter和getter 以及 计算属性的缓存讲解
    4. Spring MVC 数据响应方式
    3. SpringMVC 组件解析
    9. Vue 计算属性
    【洛谷 2984】给巧克力
    【洛谷 1821】捉迷藏 Hide and Seek
    【洛谷 1821】银牛派对Silver Cow Party
  • 原文地址:https://www.cnblogs.com/rain2020/p/12860524.html
Copyright © 2011-2022 走看看