Spring框架基础（上）

spring是开源对轻量级框架

spring核心主要两部分

aop
- 面向切面编程，扩展功能不是修改源代码实现

ioc

控制反转，把对象对创建不是通过new方式实现，而是交给spring配置创建类对象
IOC和DI区别
- IOC：控制反转，把对象创建交给spring进行配置
- DI：依赖注入，向类里面的属性中设置值
- IOC和DI关系
  - 依赖注入不能单独存在，需要在ioc基础之上完成操作

ioc操作

ioc的配置文件方式

<!-- 配置文件 -->
    <?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="userService" class="cn.xxx.auto.service.UserService"/>

    </beans>


<!-- 测试代码 -->
public class TestUtil {

    private static ApplicationContext applicationContext;

    public static void main(String[] args) {


        applicationContext = new ClassPathXmlApplicationContext("service/service.xml");

        UserService userService = (UserService) applicationContext.getBean("userService");

        userService.test();
       

    }

ioc的注解方式

ioc底层原理使用技术

xml配置文件
dom4j解决xml
工厂设计模式

反射

/**
 * ioc底层原理
 */
public class UserFactory {


    private String serviceId = "userService";

    /**
     * （1）使用dom4j解析xml方法
     * （2）使用反射创建对象
     *
     * @return 返回UserService对象的方法
     */
    public UserService getUserService() {
        //导入dom4j.jar
        SAXReader saxReader = new SAXReader();

        //获取指定xml文件
        URL url = this.getClass().getClassLoader().getResource("service/service.xml");
        try {
            Document document = saxReader.read(url);
            //获取根结点
            Element rootElement = document.getRootElement();

            //获取根结点下的子节点
            List elements = rootElement.elements();
            String serviceClass = "";
            //遍历取出子节点
            for (int i = 0; i < elements.size(); i++) {
                //获取子节点
                Element element = (Element) elements.get(i);
                //获取子节点下的参数
                Attribute idAttribute = element.attribute("id");
                Attribute classAttribute = element.attribute("class");

                if (serviceId.equals(idAttribute.getValue())) {
                    serviceClass = classAttribute.getValue();
                    break;
                }
            }

            System.out.println(serviceClass);

            Class<?> newClass = Class.forName(serviceClass);

            return (UserService) newClass.newInstance();
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }


        return null;
    }


     /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        UserFactory service = new UserFactory();
        UserService userService = service.getUserService();
        userService.test();
    }
}

spring是一站式框架
- spring在javaee三层架构中，每一层都提供不同的解决技术
  - web层：SpringMvc
  - service层：spring的ioc
  - dao层：spring的jdbcTemplate
spring入门（ioc，service的创建）
- 导入jar包
  - 做spring最基本功能时,只需要导入beans、core、context、expression这四个jar包
  - 导入支持日志输出的jar包，commons-logging-1.2.jar
- 创建类，在类里面创建方法
```
public class UserService  {

    public void test(){
        System.out.println("获取成功");
    }
}
```
- 创建spring配置文件，配置创建类
  - 建议放到src下面，官方建议applicationContext.xml
  - 引入schema约束（spring/framework/reference/html/xsd-configuration.html）
- 写代码测试对象创建

spring的bean管理（xml配置文件）

bean是实例化的方式

使用类的无参数构造创建

<bean id="user" class="cn.xxx.auto.pojo.User"/>

使用静态工厂创建

public class UserFactory  {


    public static User getUser() {

        return new User();
    }


}


<!-- 配置文件 -->
<!-- 
        destroy-method：静态工厂中的静态方法
    -->
    <bean id="user" class="cn.xxx.auto.factory.UserFactory" destroy-method="getUser"/>

使用实例工厂创建

public class UserFactory  {


    public User getUser() {

        return new User();
    }


}


<!-- 配置文件 -->
<!-- 
        factory-bean：实例工厂中的对象
        factory-method：实例工厂中的方法
    -->
    <bean id="userFactory" class="cn.xxx.auto.factory.UserFactory" destroy-method="getUser"/>
    <bean id="user" factory-bean="userFactory" factory-method="getUser" />

bean标签常用属性
- id属性
  - 起名称，id属性名称任意命名。
  - 通过id值得到配置对象
- class属性
  - 创建对象所在类的全路径
- name属性
  - 功能与id属性一样
  - 与id属性区别在于，id不可以包含特殊符号
- scope属性
  - singleton：默认值。单例。获取都是同一个对象
  - prototype：多例。获取是不同对象
  - request：创建对象把对象放到request域里面
  - session：创建对象把对象放到session域里面
  - globalSession：创建对象把对象放到globalSession域里面

属性注入方式

使用set方法注入

/**
* 测试代码
*/
public class TestUtil {

　　private String obj;

    public void setObj(String obj) {
        this.obj = obj;
    }
    public void test(){
　　    System.out.println("obj="+obj);
    }
 
     public static void main(String[] args) {


            TestUtil testUtil = new TestUtil();
            testUtil.setObj("obj");
            test();
    }
}


  <!-- 使用有参数构造注入属性 -->
    <bean id="user" class="cn.muriel.mybatis.utils.TestUtil">
        <!-- 使用有参构造注入 -->
        <property name="obj" value="obj"/>
    </bean>

有参数构造注入

/**
* 测试代码
*/
public class TestUtil {


    public TestUtil(String obj) {
        System.out.println(obj);
    }
 
     public static void main(String[] args) {


            TestUtil testUtil = new TestUtil("obj");
    }
}


  <!-- 使用有参数构造注入属性 -->
    <bean id="user" class="cn.muriel.mybatis.utils.TestUtil">
        <!-- 使用有参构造注入 -->
        <constructor-arg name="obj" value="obj"/>
    </bean>

使用接口注入（spring不支持）

spring注入属性（有参构造和set方法）

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">


    <bean id="userDao" class="cn.xxx.auto.dao.UserDao"></bean>

</beans>



<?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">

    <!-- 导入文件 -->
    <import resource="classpath:dao/dao.xml"/>


    <bean id="userService" class="cn.xxx.auto.service.UserService">
        <!--
            注入dao对象：
            name：service类里面属性名称
            value：赋值给name的字符串
            ref：赋值给name的对象，配置bean的id值
        -->
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>


public class UserService {

    //声明mapper对象
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUser() {

        System.out.println("测试");
    }
}



/**
* 测试代码
*/
public class TestUtil {


    public static void main(String[] args) {


    

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("service/service.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");




        userService.setUserDao(userDao);

        userService.addUser();
    }

}

p名称空间注入

<?xml version="1.0" encoding="UTF-8" ?>
<!-- 
      引入名称空间p：xmlns:p="http://www.springframework.org/schema/p"
 -->
<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">


    <bean id="userDao" class="cn.xxx.auto.dao.UserDao"></bean>

</beans>



<?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">

    <!-- 导入文件 -->
    <import resource="classpath:dao/dao.xml"/>


    <bean id="userService" class="cn.xxx.auto.service.UserService" p:pname-ref="userDao>
      
    </bean>

</beans>


public class UserService {

    //声明mapper对象
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUser() {

        System.out.println("测试");
    }
}



/**
* 测试代码
*/
public class TestUtil {


    public static void main(String[] args) {


    

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("service/service.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");




        userService.setUserDao(userDao);

        userService.addUser();
    }

}

spring注入复杂数据

数组
list集合
map集合

properties类型

<?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.xxx.auto.dao.UserDao"></bean>

</beans>



<?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="userService" class="cn.xxx.auto.service.UserService">
        <!--
           arrs：
        -->
        <property name="arrs">
                <list>
                    <value>1</value>
                    <value>2</value>
                    <value>3</value>
                </list>
        </property>
        <!--
           list：
        -->
       <property name="list">
                <list>
                    <value>11</value>
                    <value>22</value>
                    <value>33</value>
                </list>
        </property>
        <!--
           map：
        -->
        <property name="map">
                <map>
                    <entry key="username" value="aa"></entry>
                    <entry key="password" value="bb"></entry>
                </map>
        </property>
        <!--
           
        -->
        <property name="properties">
                <props>
                    <prop key="username">aa</prop>
                    <prop key="password">bb</prop>
                </list>
        </property>

    </bean>

</beans>


public class UserService {

   
    private String[] arrs;
    private List<String> list;
    private Map<String,String> map;
    private Properties properties;


    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMap(Map<String,String> map) {
        this.map = map;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void addUser() {

        System.out.println("arrs="+arrs);
        System.out.println("list="+list);
        System.out.println("map="+map);
        System.out.println("properties="+properties);
    }
}



/**
* 测试代码
*/
public class TestUtil {


    public static void main(String[] args) {


    

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("service/service.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");




        userService.setUserDao(userDao);

        userService.addUser();
    }

}

Spring框架基础（上）

猜你喜欢