Spring

最新推荐文章于 2023-10-17 08:00:00 发布

mry6

最新推荐文章于 2023-10-17 08:00:00 发布

阅读量185

点赞数

分类专栏： spring

本文链接：https://blog.csdn.net/muriyue6/article/details/81982011

版权

spring 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

Spring概念

1) Spring是开源的轻量级框架

2) Spring核心主要有两部分

* aop: 面向切面编程, 扩展功能不用修改源代码实现

*ioc: 控制反转, 比如有一个类, 在类里面有方法(不是静态方法), 调用类里面的方法时, 需要创建类的对象, 使用对象调用方法, 创建类对象的过程, 通过new出来对象

ioc是把对象的创建不是通过new方式实现, 而是交给Spring配置创建类对象

3) Spring是一站式框架

* Spring在javaee三层结构中, 每一层都提供不同的解决技术

web层: SpringMVC

service层: Spring的ioc

dao层: Spring的jdbcTemplate

Spring的Bean管理(xml方式)

Bean实例化的方式

(1) 在Spring里面通过配置文件创建对象

(2) Bean实例化的三种方式实现

第一种使用类的无参构造创建(重点)

<bean id="user" class="com.aitsys.demo.controller.User"></bean>

类里面没有无参构造会抛异常

第二种使用静态工厂创建

1) 创建静态的方法, 返回类对象

package com.spring;
/**
* Created by gailun on 2018/7/25.
*/
public class Bean2 {

    public void add(){
        System.out.println("Bean2...........");
    }
}

package com.spring;
/**
* Created by gailun on 2018/7/25.
*/
public class Bean2Factory {
    //静态的方法, 返回Bean2对象
    public static Bean2 getBean2(){
        return new Bean2();
    }
}

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


        <!--使用静态工厂创建对象-->
        <bean id="bean2" class="com.spring.Bean2Factory" factory-method="getBean2"></bean>
</beans>

package com.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* Created by gailun on 2018/7/25.
*/
public class Bean2Test {
    public static void main(String[] args) {
        //1.加载spring配置文件, 根据创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //2. 得到配置创建的对象
        Bean2 bean2 = (Bean2) context.getBean("bean2");
        System.out.println(bean2);
    }
}

执行结果:

第三种使用实例化工厂创建

1) 创建不是静态的方法, 返回类对象

package com.spring;
/**
* Created by gailun on 2018/7/25.
*/
public class Bean3 {
    public void add(){
        System.out.println("Bean3...........");
    }
}

package com.spring;
/**
* Created by gailun on 2018/7/25.
*/
public class Bean3Factory {
    //普通的方法, 返回Bean3对象
    public Bean3 getBean3(){
        return new Bean3();
    }
}

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


        <!--使用静态工厂创建对象-->
        <bean id="bean2" class="com.spring.Bean2Factory" factory-method="getBean2"></bean>

        <!--使用实例化工厂创建对象-->
        <!--创建工厂对象-->
        <bean id="beanFactory" class="com.spring.Bean3Factory"></bean>
        <bean id="bean3" factory-bean="beanFactory" factory-method="getBean3"></bean>
</beans>

package com.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Created by gailun on 2018/7/25.
*/
public class Bean3Test {
    public static void main(String[] args) {
        //1.加载spring配置文件, 根据创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //2. 得到配置创建的对象
        Bean3 bean3 = (Bean3) context.getBean("bean3");
        System.out.println(bean3);
    }
}

执行结果:

(3) Bean标签常用属性

1) id属性: 起名称, id属性值名称任意命名; id属性值不能包含特殊符号; 根据id值得到配置对象

2) class属性: 创建对象所在类的全路径

3) name属性: 功能和id属性一样的, id属性值不能包含特殊符号, 但是在name属性值里面可以包含特殊符号

4) scope属性:

(4) 属性注入

1) 创建对象时候, 向类里面属性里面设置值

2) 属性注入的方式介绍(三种方式)

* 使用set方法注入

* 使用有参数构造注入

* 使用接口注入

3) 在Spring框架里面, 支持前两种方式

* set 方法注入

* 有参数构造注入

(5) 注入对象类型属性(重点)

在service得到dao对象

具体实现过程:

1) 在service里面把dao作为类型属性

2) 生成dao类型属性的set方式

package com.spring;
/**
* Created by gailun on 2018/7/26.
*/
public class UserDao {
    public void add(){
        System.out.println("dao..............");
    }
}

package com.spring;
/**
* Created by gailun on 2018/7/26.
*/
public class UserService {
    //1. 定义dao类型属性
    private UserDao userDao;

    //2. 生成set方法
    public void setUserDao(UserDao userDao){
        this.userDao=userDao;
    }

    public void add(){
        System.out.println("service.........");
        //在service里面得到dao类对象, 才能调用dao里面的方法
        userDao.add();
    }
}

3) 配置文件中注入关系

<!--注入对象类型属性-->
<!--1.配置service和dao对象-->
<bean id="userDao" class="com.spring.UserDao"></bean>
<bean id="userService" class="com.spring.UserService">
     <!--注入dao属性,
                name属性值: service类里面属性名称;
        现在不要写value属性, 因为刚才是字符串, 现在是对象;
        写ref属性: dao配置bean标签中id值-->
     <property name="userDao" ref="userDao"></property>
</bean>

(6) 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"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xsi:schemaLocation="http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">


        <!--使用静态工厂创建对象-->
        <bean id="bean2" class="com.spring.Bean2Factory" factory-method="getBean2"></bean>

        <!--使用实例化工厂创建对象-->
        <!--创建工厂对象-->
        <bean id="beanFactory" class="com.spring.Bean3Factory"></bean>
        <bean id="bean3" factory-bean="beanFactory" factory-method="getBean3"></bean>

        <!--注入对象类型属性-->
        <!--1.配置service和dao对象-->
        <bean id="userDao" class="com.spring.UserDao"></bean>
        <bean id="userService" class="com.spring.UserService">
             <!--注入dao属性,
                name属性值: service类里面属性名称;
        现在不要写value属性, 因为刚才是字符串, 现在是对象;
        写ref属性: dao配置bean标签中id值-->
             <property name="userDao" ref="userDao"></property>
        </bean>

        <!--p名称空间注入-->
        <bean id="person" class="com.spring.Person" p:pname="pname"></bean>
</beans>

package com.spring;
/**
* Created by gailun on 2018/7/27.
*/
public class Person {
    private String pname;

    public void setPname(String pname) {
        this.pname = pname;
    }

    public void test1(){
        System.out.println("person....."+pname);
    }
}

package com.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* Created by gailun on 2018/7/27.
*/
public class PersonTest {
    public static void main(String[] args) {
        //1.加载spring配置文件, 根据创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //2. 得到配置创建的对象
        Person person = (Person) context.getBean("person");
        System.out.println(person);
    }
}

执行结果:

(7) 注入复杂类型

1) 数组

2) list集合

3) map集合

4) 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"
        xmlns:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xsi:schemaLocation="http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">


        <!--使用静态工厂创建对象-->
        <bean id="bean2" class="com.spring.Bean2Factory" factory-method="getBean2"></bean>

        <!--使用实例化工厂创建对象-->
        <!--创建工厂对象-->
        <bean id="beanFactory" class="com.spring.Bean3Factory"></bean>
        <bean id="bean3" factory-bean="beanFactory" factory-method="getBean3"></bean>

        <!--注入对象类型属性-->
        <!--1.配置service和dao对象-->
        <bean id="userDao" class="com.spring.UserDao"></bean>
        <bean id="userService" class="com.spring.UserService">
             <!--注入dao属性,
                name属性值: service类里面属性名称;
        现在不要写value属性, 因为刚才是字符串, 现在是对象;
        写ref属性: dao配置bean标签中id值-->
             <property name="userDao" ref="userDao"></property>
        </bean>

        <!--p名称空间注入-->
        <!--<bean id="person" class="com.spring.Person" p:pname="pname"></bean>-->

        <!--注入复杂类型属性值-->
        <bean id="person" class="com.spring.Person">
            <!--数组-->
            <property name="arrs">
                <list>
                    <value>生活</value>
                    <value>吃饭</value>
                    <value>奋斗</value>
                </list>
            </property>

            <!--list-->
            <property name="list">
                <list>
                    <value>小生</value>
                    <value>小吃</value>
                    <value>小奋</value>
                </list>
            </property>

            <!--map-->
            <property name="map">
                <map>
                    <entry key="aa" value="lucy"></entry>
                    <entry key="bb" value="tom"></entry>
                    <entry key="cc" value="mali"></entry>
                </map>
            </property>

            <!--properties-->
            <property name="properties">
                <props>
                    <prop key="driverclass">com.mysql.jdbc.Driver</prop>
                    <prop key="username">root</prop>
                    <prop key="password">root</prop>
                </props>
            </property>

        </bean>
</beans>

package com.spring;
import java.util.List;
import java.util.Map;
import java.util.Properties;
/**
* Created by gailun on 2018/7/27.
*/
public class Person {
    private String pname;

    public void setPname(String pname) {
        this.pname = pname;
    }

    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 test1(){
        System.out.println("person....."+pname);
        System.out.println("arrs:"+arrs);
        System.out.println("list:"+list);
        System.out.println("map:"+map);
        System.out.println("properties:"+properties);
    }
}

package com.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Created by gailun on 2018/7/27.
*/
public class PersonTest {
    public static void main(String[] args) {
        //1.加载spring配置文件, 根据创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //2. 得到配置创建的对象
        Person person = (Person) context.getBean("person");
        person.test1();

    }
}

执行结果:

(8) IOC和DI区别

1) IOC: 控制反转, 把对象创建交给spring进行配置

2) DI: 依赖注入, 向类里面的属性中设置值

3) 关系: 依赖注入不能单独存在, 需要在IOC基础之上完成操作

(9) Spring整合web项目原理

1) 加载spring核心配置文件

//1.加载spring配置文件, 根据创建对象
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

2) new对象, 功能可以实现, 效率很低

3) 实现思想: 把加载配置文件和创建对象过程, 在服务器启动时候完成

4) 实现原理

* ServletContext对象

* 监听器

* 具体使用:

在服务器启动时候, 为每个项目创建一个ServletContext对象

在ServletContext对象创建时候, 使用监听器可以具体到ServletContext对象在什么时候创建

使用监听器监听到ServletContext对象

加载spring配置文件, 把配置文件配置对象创建

把创建出来的对象放到ServletContext域对象里面(setAttribute()方法)

获取对象时候, 到ServletContext域得到(getAttribute()方法)

(10) Spring的Bean管理(注解)

注解介绍:

* 代码里面特殊标记, 使用注解可以完成相关的功能

* 注解写法@注解名称(属性名称=属性值)

* 注解使用在类上面, 方法上面和属性上面

Spring注解开发准备:

* 导入基本的jar包

* 导入aop的jar包

* 创建类, 创建方法

package com.spring;
/**
* Created by gailun on 2018/7/28.
*/
public class User {
    public void add(){
        System.out.println("add.............");
    }
}

* 创建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"
        xmlns:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xsi:schemaLocation="http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd">


       
</beans>

* 开启注解扫描

<!--开启注解扫描-->
<context:component-scan base-package="com.spring"></context:component-scan>

1) 使用注解创建对象

* 在创建对象的类上面使用注解实现

package com.spring;
import org.springframework.stereotype.Component;

/**
* Created by gailun on 2018/7/28.
*/
@Component(value = "user") // 等价于 <bean id="user" class="/>
public class User {
    public void add(){
        System.out.println("add.............");
    }
}

package com.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* Created by gailun on 2018/7/28.
*/
public class UserTest {
    public static void main(String[] args) {
        //1.加载spring配置文件, 根据创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = (User) context.getBean("user");
        user.add();
    }
}

执行结果:

* 创建对象单实例还是多实例

@Component(value = "user") // 等价于 <bean id="user" class="/>
@Scope(value = "prototype")
public class User {

2) 使用注解注入属性

package com.spring;
import org.springframework.stereotype.Component;
/**
* Created by gailun on 2018/7/28.
*/
@Component(value = "userDao")
public class UserDao1 {
    public void add(){
        System.out.println("UserDao1.............");
    }
}

package com.spring;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* Created by gailun on 2018/7/28.
*/
@Service(value = "userService")
public class UserService1 {

    //得到dao对象
    //1.定义Dao类型属性
    //在dao属性上面使用注解完成对象注入
    @Autowired
    private UserDao1 userDao1;
    //使用注解方式时候不需要set方法
    public void add(){
        System.out.println("UserService1...........");
        userDao1.add();
    }
}

package com.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* Created by gailun on 2018/7/28.
*/
public class UserTest {
    public static void main(String[] args) {
        //1.加载spring配置文件, 根据创建对象
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //User user = (User) context.getBean("user");
        //user.add();
        UserService1 userService1 =(UserService1) context.getBean("userService");
        userService1.add();
    }
}

执行结果:

3) xml和注解方式混合使用

(11) AOP

1) aop概述

* aop: 面向切面(方面)编程, 扩展功能不修改源代码实现

* aop: 采取横向抽取机制, 取代了传统纵向继承体系重复性代码

2) aop底层原理

mry6

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring

Spring概念1) Spring是开源的轻量级框架2) Spring核心主要有两部分 * aop: 面向切面编程, 扩展功能不用修改源代码实现 *ioc: 控制反转, 比如有一个类, 在类里面有方法(不是静态方法), 调用类里面的方法时, 需要创建类的对象, 使用对象调用方法, 创建类对象的过程, 通过new出来对象 ioc是把对象的创建不是通过ne...
复制链接

扫一扫