spring（春天）

最新推荐文章于 2024-08-30 19:56:58 发布

置顶程序员？》《

最新推荐文章于 2024-08-30 19:56:58 发布

阅读量218

点赞数

分类专栏： Java学习笔记 Java 文章标签： spring java

本文链接：https://blog.csdn.net/m0_57652176/article/details/118098870

版权

Java学习笔记同时被 2 个专栏收录

18 篇文章 0 订阅

订阅专栏

Java

17 篇文章 0 订阅

订阅专栏

IOC操作Bean管理两种方式(创建类和注入属性的方式)

spring案例

1.新建一个普通java文件

2.引入spring的jar包

3.创建一个普通类，类中创建普通方法

4.创建一个配置文件或者通过注解来创建的那个对象

（1）spring配置文件使用xml格式

<?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">
    <!--配置user对象创建-->
    <bean id="test" class="comm.Test"></bean><!--无参构造创建对象-->
</beans>

5.测试代码编写

public class TestSpring {
    @Test
    public void test(){
        //加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //获取配置文件创建的对象
        User user = context.getBean("user",User.class);//万一这么多对象，你怎么知道是那个user,后面的参数就告诉你是User类型的对象
        user.add();
    }
}

spring优点

spring理念：使现有的技术更容易使用，本身是一个大杂烩，整合了现有技术框架。

弊端：发展太久之后，违背了原来的理念！配置十分繁琐。人称：“配置地狱”

spring是一个开源的免费的框架（容器）！

spring是一个轻量级，非入侵式框架！

控制反转（IOC）：把创建对象交给spring管理，

面向切面编程（AOP）：不修改源代码进行功能增强

支持事务处理，对框架整合的支持

总结：spring就是一个轻量级的控制反转（IOC）和面向切面编程的框架（AOP）的框架。

组成

spring Boot：一个快速开发的脚手架，基于springBoot可以快速开发一个单个微服务

spring cloud：springcloud是基于spring boot实现的。

引入基础jar包

beans，core，context，expression

IOC理论

1.什么是IOC？

（1）.把对象创建和对象之间的调用过程交给spring进行管理

（2）.使用IOC目的：为了降低耦合度

(3).入门案例就是IOC实现

2.IOC的底层原理使用技术

（1）xml配置文件

（2）dom4解析xml

（3）工厂设计模式

（4）反射

第一步 xml配置文件，配置创建的对象

<?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">
    <!--配置user对象创建-->
    <bean id="test" class="comm.Test"></bean>
</beans>

第二步有service类和dao类，创建的工厂类

class userFactory{
    public static  UserDao getDao(){
        String classvalue = class属性值;//xml解析
        Class clazz = Class.forName(classvalue);
        return (userDao)clazz.newInstance();
    }
}

3.IOC接口

（1）.IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

（2）.Spring提供IOC容器实现的两种方式（两个接口）

beanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供给开发人员使用，但是也可以用。加载配置文件的时候不会创建对象，在获取对象（使用）才去创建对象

ApplicationContest：是beanFactory接口的子接口，提供了更加强大的功能，一般由开发人员使用。加载配置文件时候就创建了对象

ApplicationContest有两个实现类：一个是FileSystemSmlApplicationContest（系统盘路径），另一个是ClasspathXmlApplicationContest（src路径）。

IOC容器--Bean管理xml的方式

什么是bean管理？

Bean管理指的两个操作：

（1）Spring创建对象

（2）Spring注入属性

IOC操作Bean管理两种方式(创建类和注入属性的方式)

IOC的配置文件（xml）方式

xml方式创建对象：创建对象的时候默认是无参构造，因为必须有无参构造方法

在spring的配置文件中，使用Bean标签，在标签里面加入对应属性，就可以实现这个对象创建。

标签属性：

id：获取对象的那个唯一的标识

class：创建对象所在那个类的一个全路径

name：name其实跟id标签效果相同，只是name可以加入特殊符号，而id不行。

 <bean id="user" class = "com.atguigu.spring5.User"></bean>

xml方式注入属性：

DI：依赖注入，就是注入属性，要在创建对象的基础之上完成

第一种注入方式：原始方法，利用set方法注入。

/*
* 演示set方法注入属性
* */
public class Book {
    //创建属性
    private String bname;
    private String bauthor;
    //对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
//本来在main方法调用set方法就好了。现在去Spring配置文件配置对象创建，配置属性注入。
    /*public static void main(String[] args) {
        Book book = new Book();
        book.setBname("ssss");
    }*/
}

set方法--------property

<?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">
    <!--配置Book对象创建-->
    <bean id="book" class = "com.atguigu.spring5.Book">
        <!--set方法注入属性，使用property完成属性注入-->
        <property name="bname" value="辟邪剑法"></property>
        <property name="bauthor" value="林平之"></property>
    </bean>
</beans>

public class TestDemo {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Book book = context.getBean("book",Book.class);
        book.print();
    }
}

第二种注入方式：有参构造注入

public class Order {
    private String oname;
    private String address;

    public Order(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
    public void print(){
        System.out.println(oname+":"+address);
    }
}

有参构造--------------constructor-arg

<?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="order" class="Order">
        <constructor-arg name="oname" value="洗发水"></constructor-arg>
        <constructor-arg name="address" value="长沙"></constructor-arg>
        <constructor-arg index="0" value="ss"></constructor-arg>//代表有参构造第一个参数
    </bean>
</beans>

public class TestDemo {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        Order order = context.getBean("order",Order.class);
        order.print();
    }
}

p名称空间注入

1.使用p名称空间注入，可以简化基于xml配置方式。

第一步添加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">

第二步进行属性注入

    <!--配置Book对象创建-->
    <bean id="book" class = "Book" p:bname="九阳神功" p:bauthor="无名氏">
    </bean>
</beans>

xml注入其他类型属性。比如字面量为null或者含有一些特殊符号。

意思就是把address属性设置为null

<?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">
    <!--配置Book对象创建-->
    <bean id="book" class = "Book">
        <property name="bname">
            <null/>
        </property>
        <property name="bauthor">
            <null/>
        </property>
    </bean>
</beans>

把address属性设置成特殊符号

<?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">
    <!--配置Book对象创建-->
    <bean id="book" class = "Book">
        <property name="bname">
            <value><![CDATA[......]]></value>
        </property>
        <property name="bauthor">
            <null/>
        </property>
    </bean>
</beans>

注入属性---外部bean

使用场景：创建了两个类service和dao类，在service调用dao里面的方法，在spring配置文件中进行配置。

public class UserService {
    private UserDao userDao;

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

    public void test(){
        System.out.println("add.....");
    }
    public void add(){
        System.out.println("service add..........");
        userDao.update();
    }
}

public class UserDaoiml implements  UserDao{
    @Override
    public void update() {
        System.out.println("dao update.....");
    }
}

<?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="service.UserService">
        <!--通过set方法来注入属性-->
        <!--name属性：类里面的属性名称
            ref属性：创建userdao对象bean标签的id值-->
        <property name="userDao" ref="userdaoiml"></property>
    </bean>
    <bean id="userdaoiml" class="dao.UserDaoiml"></bean>
</beans>

public class Bean1Test {
    @Test
    public void test(){
        //加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bea2.xml");
        //获取配置文件创建的对象
        UserService userService = context.getBean("userservice",UserService.class);
        userService.add();
    }

}

（1）一对多关系，部门和员工。

(2)在实体类中表示一对多关系。

注入属性--内部bean和级联赋值

public class Emp {
    private String ename;
    private String gender;
    private  Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
    public void add(){
        System.out.println(ename+":"+
                gender+":"+
                dept);
    }
}

package bean;

public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

内部bean

<?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="emp" class="bean.Emp">
        <!--注入属性-->
        <!--id:是创建对象的名字
            class：是创建对象的类包
            name：是要注入的属性
            value：是要注入的属性值，不包括自定义类
            ref：是要注入的属性是自定义类，而且是一个对象，是要注入一个外部bean，因此我们需要注入一个对象，因此我们把外部bean的id给ref。其实ref就是S s = new S（）；的new S（）。外部的对象用ref引入-->
        <property name="ename" value="李祖德"></property>
        <property name="gender" value="男"></property>
        <!--<property name="dept" ref="dept"></property>-->
        <property name="dept">
            <bean id="dept" class="bean.Dept">
                <property name="dname" value="it"></property>
            </bean>
        </property>
    </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="emp" class="bean.Emp">
        <property name="ename" value="李祖德"></property>
        <property name="gender" value="男"></property>
    </bean>
    <bean id="dept" class="bean.Dept">
        <property name="dname" value="ll"></property>
    </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="emp" class="bean.Emp">
        <property name="ename" value="李祖德"></property>
        <property name="gender" value="男"></property>
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="ss"></property>
    </bean>
    <bean id="dept" class="bean.Dept">
        <property name="dname" value="ll"></property>
    </bean>
</beans>

public class beanTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean8.xml");//只能是在scr文件下，在其他文件下会报错
        Emp emp = context.getBean("emp" ,Emp.class);
        emp.add();
    }
}

xml注入集合属性：

1.注入数组类型属性

2.注入List集合属性

3.注入Map集合类型属性

(1) 创建类，定义数组，list，Map，set类型属性，生成对应set方法

public class Stu {
    private  String[] courses;
    private List<String> list;
    private Map<String,String> map;
    private Set<String> set;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void add(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(map);
        System.out.println(set);
    }
}

（2）在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="stu" class="collectiontype.Stu">
        <property name="courses">
            <array>
                <value>java</value>
                <value>sql</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="SQL" value="sql"></entry>
             </map>
        </property>
        <property name="set">
            <set>
                <value>maysql</value>
                <value>redius</value>
            </set>
        </property>
    </bean>
</beans>

(3).测试类

public class SpringTest {
    @Test
    public void test(){
        ApplicationContext contest = new FileSystemXmlApplicationContext("E:\\Bean02\\src\\collectiontype\\bean1.xml");
        Stu stu = contest.getBean("stu",Stu.class);
        stu.add();
    }
}

4.在集合里面设置对象类型值

(1) 创建类，定义数组，list，Map，set类型属性，生成对应set方法

public class Stu {
    private  String[] courses;
    private List<String> list;
    private Map<String,String> map;
    private Set<String> set;
    //学生所学多门课程
    private List<Course> courselist;

    public void setCourselist(List<Course> courselist) {
        this.courselist = courselist;
    }


    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void add(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(map);
        System.out.println(set);
        System.out.println(courselist);
    }
}

集合里面设置的类

public class Course {
    private String cname;

    public void setCname(String cname) {
        this.cname = cname;
    }

    @Override
    public String toString() {
        return "Course{" +
                "cname='" + cname + '\'' +
                '}';
    }
}

（2）在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="stu" class="collectiontype.Stu">
        <property name="courses">
            <array>
                <value>java</value>
                <value>sql</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="SQL" value="sql"></entry>
             </map>
        </property>
        <property name="set">
            <set>
                <value>maysql</value>
                <value>redius</value>
            </set>
        </property>
        <!--注入list集合类型，但是他的值是一个对象-->
        <property name="courselist">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
                <ref bean="course3"></ref>
            </list>
        </property>
    </bean>
    <!--创建多个course对象-->
    <bean id="course1" class="collectiontype.Course">
        <property name="cname" value="数学"></property>
    </bean>
    <bean id="course2" class="collectiontype.Course">
        <property name="cname" value="语文"></property>
    </bean>
    <bean id="course3" class="collectiontype.Course">
        <property name="cname" value="英语"></property>
    </bean>
</beans>

(3).测试类

public class SpringTest {
    @Test
    public void test(){
        ApplicationContext contest = new FileSystemXmlApplicationContext("E:\\Bean02\\src\\collectiontype\\bean1.xml");
        Stu stu = contest.getBean("stu",Stu.class);
        stu.add();
    }
}

5.把集合注入部分提取出来，让他成为一个公共部分，让其他对象也可使用。如果没有提取出来只可以在当前bean标签使用，而其他的bean标签不能使用。

（1）在spring配置文件中引入名称空间util

Book类：

public class Book {
    private List<String> list;
    public void setList(List<String> list) {
        this.list = list;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:util = "http://www.springframework.org/schema/util"
       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
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<!--引入util-->
<!--把beans改为util-->
    
</beans>

（2）使用util标签完成list集合注入提取

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:util = "http://www.springframework.org/schema/util"
       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
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<!--提取list集合类型属性注入-->
    <util:list id="booklist">
        <value>易筋经</value>
        <value>九阴真经</value>
        <value>降龙十八掌</value>
    </util:list>
    <!--提取list集合类型属性注入使用-->
    <bean id="book" class="collectiontype.Book">
        <property name="list" ref="booklst"></property>
    </bean>
</beans>

IOC操作Bean管理（FactoryBean）

1.Spring有两种类型的bean，一种普通的bean，另外一种bean是FactoryBean（工厂Bean）。

2.普通bean在Spirng配置文件中定义bean类型就是返回类型

3.工厂bean：在配置文件定义的bean类型和返回类型不一样

第一步创建类，让这个类作为工厂bean，实现FactoryBean

第二步实现接口里面的方法，在实现的方法中定义返回bean类型

bean的作用域：

1.在Spring里面，设置创建bean实例是单实例还是多实例，任何设置呢？

在Spring里面有一个属性设置是单实例还是多实例（Scope）

scope属性值第一个值默认值 singleton表示单实例对象

第二个值 prototype表示多实例对象

sington与prototype区别

第一：singleton是单实例，prototype是多实例

第二：设置scope值是singleton时候，加载spring配置文件时候就会创建单实例对象

设置scope值是prototype时候，不是加载Spring配置文件时候创建对象，而在调用getbean方法时候去创建多实例对象。

2.在Spring里面，默认情况下，bean是一个单实例对象

如果是多实例那么每一次获取对象应该都是不同的对象，然而确实是单实例。

public class FactoryBean {
    @Test
    public void test(){
        ApplicationContext context = new FileSystemXmlApplicationContext("E:\\zw\\src\\bean.xml");
        User user1 = context.getBean("user",User.class);
        User user2 = context.getBean("user",User.class);
        System.out.println(user1);//user1与user2的地址相同
        System.out.println(user2);
    }
}

bean的生命周期：

1.什么是生命周期？

从对象创建到销毁的过程

2.bean的生命周期

（1）通过构造器创建bean实例（无参数构造）

（2）为bean的属性设置值和对其他bean的引用（调用set方法）

（3）把bean的实例传给bean的后置处理器的方法（必须配置了后置处理器）

postProcessBeforeInitialization

（3）调用bean的初始化方法（需要进行配置初始化方法）

（5）把bean实例传递给bean后置处理器的方法（必须配置了后置处理器）

postProcessAfterInitialization

（4）bean可以使用(获取到了创建的对象）

（5）当容器关闭时候，调用bean的销毁方法（需要进行配置销毁方法）

加上bean的后置处理器：bean生命周期有七步

演示添加后置处理器效果

（1）创建类，实现BeanPostProcessor接口，创建后置处理器

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之后执行的方法");
        return bean;
    }
}

（2）配置后置处理器

<?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="orders" class="Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="手机"></property>
    </bean>
    <!--配置后置处理器：当你添加后置处理器之后，所有的bean都将添加后置处理器，处理器类中
有两个方法，一个在初始化之前执行，一个在初始化之后执行-->
    <bean id="myBeanPost" class="MybeanPost"></bean>
</beans>

xml自动装配

自动装配：注入属性通过一些标签比如Property来手动装配

<property name="oname" value="手机"></property>

（1）根据指定装配规则（属性名或者属性类型），Spring自动将配置的属性值进行注入

（2）演示自动装配过程

<?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="dept" class="Dept"></bean>
    <bean id="emp" class="Emp" autowire="byName"></bean>
    <!--autowire标签属性，自动装配
        byName根据属性名称注入，注入值bean的id和类属性名称一样
        bytype根据属性类型注入，
        加载配置文件，根据配置文件找到那个类的对象，然后创建了对象之后发现有自动装配，如果是根据名字就要求bean的id和类属性名称一样。如果是根据类型，就要求同一种类型的对象不能创建多个在bean.xml
       文件中-->
</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="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

引入外部属性文件配置数据库连接池

(1)创建外部属性文件，.properties格式文件，写数据库信息

prop.driverclass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.username=root
prop.password=root

(2)把外部properties属性引入到Spring配置文件中

*引入context名称空间

<?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:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
                            http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd">
    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:JDBC.properties"></context:property-placeholder>
    <!--配置连接池：使用spring里面的表达式${}-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverclass}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.username}"></property>
        <property name="prop.password" value="${prop.password}"></property>
    </bean>
</beans>

IOC的注解方式

注解方式创建对象：

spring针对Bean管理中创建对象提供注解：

（1）@component

（2）@service

（3）@controller

（4）@repository

上面四个注解功能是一样的，都可以用来创建对象

基于注解进行实现对象创建

(1)引入依赖

（2）开启组件扫描：告诉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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.at.spring"></context:component-scan>
</beans>

开启组件扫描细节问题：

在那个包下面开启组件扫描

<context:component-scan base-package="com.at.spring"></context:component-scan>

在那个包下开启组件扫描，没有使用默认的扫描内容，而是扫描的是注解类型，那种类型的注解

   <context:component-scan base-package="com.at.spring" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>

在那个包下开启组件扫描，没有使用默认的扫描内容，而是扫描的是注解类型，非那种类型的注解

<context:component-scan base-package="com.at.spring">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>

（3）创建类，在类上面添加创建对象注解

package com.at.spring.service;
import org.springframework.stereotype.Component;
@Component(value = "userService")//bean id="userService" class=".."
public class UserService {
    public void add(){
        System.out.println("Service add...........");
    }
}

注解方式注入属性：

(1)@AutoWired:根据属性类型自动装配

(2)@Qualifer：根据属性名称进行注入

(3)@Resource：可以根据类型注入，可以根据名称注入

（4）@Value：注入普通类型的属性

第一步：把service和dao对象创建，在service和dao类添加创建对象注解

第二步：在service注入dao对象，在service类型添加dao类型属性，在属性上面使用注解

@autoWire的使用

@Repository
public class UserDaoiml implements UserDao {

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

@Repository
public class UserService {
    @Autowired
    //不需要加入set方法
    private UserDao userDao;
    public void println(){
        System.out.println("service add........");
        userDao.add();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.at"></context:component-scan>
</beans>

public class SpringTest {
    @Test
    public void test(){
        ApplicationContext context = new FileSystemXmlApplicationContext("E:\\untitled\\src\\com\\at\\Spring\\bean.xml");
        UserService userService = context.getBean("userService",UserService.class);
        System.out.println(userService);
        userService.println();
    }
}

@Qualifer的使用：要与Autowire联合使用。

Autowire根据类型注入，但是一个类型可能有多个实现类，因此还需要加上对象名

@Repository
public class UserService {
    @Autowired
    @Qualifier(value = "userDaoiml")
    //不需要加入set方法
    private UserDao userDao;
    public void println(){
        System.out.println("service add........");
        userDao.add();
    }
}

@Resource可以根据类型注入：

@Repository
public class UserService {
    @Resource//根据类型注入
    private UserDao userDao;
    public void println(){
        System.out.println("service add........");
        userDao.add();
    }
}

也可以根据名称注入

@Repository
public class UserService {
    @Resource(name = "userDaoiml")//根据名称注入
    private UserDao userDao;
    public void println(){
        System.out.println("service add........");
        userDao.add();
    }
}

@value：注入普通属性

@Repository
public class UserService {
    @Resource(name = "userDaoiml")//根据名称注入
    private UserDao userDao;
    @Value(value = "root")
    private String username;
    public void println(){
        System.out.println("service add........");
        userDao.add();
    }

    @Override
    public String toString() {
        return "UserService{" +
                "userDao=" + userDao +
                ", username='" + username + '\'' +
                '}';
    }
}

完全注解开发：

（1）创建配置类，替代xml配置文件。

@Configuration//说明此类是Spring的配置类，代替xml配置文件
@ComponentScan(basePackages = "com.at")//组件扫描类似<context:component-scan base-package="com.at.spring"></context:component-scan>
public class SpringConfigure {
}

（2）编写测试类

    @Test
    public void test1(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfigure.class);//加载配置类
        UserService userService = context.getBean("userService",UserService.class);
        System.out.println(userService);
        userService.println();
        System.out.println(userService);
    }

AOP

什么是AOP

AOP（面向切面编程）：利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率。

通俗来讲：不通过修改源代码方式，在主干功能里面添加新的功能。而是新建一个功能模块，把这个功能模块配置到主干功能中去。

底层原理

AOP底层使用动态代理

（1）动态代理有两种情况

第一种：有接口情况，使用JDK动态代理

第二种：没有接口情况，使用CGLIB动态代理

AOP（JDK动态代理）

1.使用JDK动态代理，使用proxy类里面的方法创建动态代理

（1）调用newProxyInstance方法返回一个接口实现类代理对象

方法有三个参数：

第一参数，类加载器

第二参数，增强方法所在的类，这个类实现的接口，支持多个接口。

第三参数，实现这个接口InvocationHandler，创建代理对象，写增强的方法。

（2）.JDK动态代理代码

（1）创建接口，定义方法。

public interface UserDao {
    int add(int a,int b);
    String update(String id);
}

（2）创建接口实现类，实现方法

public class UserDaoIml implements UserDao{
    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

（3）.使用proxy类创建接口代理对象

public class JDKproxy {
    public static void main(String[] args) {
        //创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoIml userDaoIml = new UserDaoIml();
        UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKproxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDaoIml));
        int add = userDao.add(1,2);
        System.out.println(add);
    }
}
class UserDaoProxy implements InvocationHandler{
    //1.把创建的是谁的代理对象，把谁传递过来
    //有参数构造传递
    Object object;
    public UserDaoProxy(Object object){
        this.object = object;
    }
    //增强的逻辑写道invoke方法中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前执行
        System.out.println("方法之前执行................"+ method.getName()+":传递参数."+ Arrays.toString(args));
        //被增强的方法执行
        Object res = method.invoke(object,args);
        //方法之后
        System.out.println("方法之后执行。。。。"+object);
        return res;
    }
}

AOP术语

1.连接点

2.切入点

3.通知（增强）

4.切面

AOP的操作（准备工作）

1.在Spring框架中一般基于AspectJ实现AOP操作

（1）什么是Aspectj：它不是Spring的组成部分，独立的AOP框架。一般把AspectJ和Spring框架一起使用，进行AOP操作。

2.基于AspectJ实现AOP操作

（1）基于xml配置文件实现

（2）基于注解方式实现

3.在项目过程里面引入AOP相关依赖

4.切入点表达式

（1）切入点表达式作用：知道对那个类里面的那个方法进行增强

（2）语法结构：

execution （[权限修饰符] [返回类型] [类的全路径] [方法名称]）

举例1：对com.at.dao.BookDao类里面的add进行增强

execution（*com.at.dao.BookDao.add(..)）

*代表任一一个权限修饰符，返回值类型可以省略，类的全路径然后.方法名，方法名后面括号加上（..）代表参数列表

举例2：对com.at.dao.BookDao类里面所有的方法进行增强

execution（*com.at.dao.BookDao.*(..)）

举例3：对com.at.dao包里所有类，类里面所有的方法进行增强

execution（*com.at.dao.*.*(..)）

AOP操作（注解）

1.创建类，在类里面定义方法

2.创建增强类：对这个方法写增强，我们对这个方法编写什么增强逻辑

（1）在增强类里面，创建方法，让不同的方法代表不同的通知类型

3.进行通知的配置

（1）在spring配置文件中，开启注解扫描

（2）使用注解创建user和userproxy对象

（3）在增强类上面添加注解@Aspect，用这个类生成一个代理对象

（4）在spring配置文件中开启生成代理对象，配置切面。

4.配置不同类型的通知

（1）在增强类里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

//被增强的类
@Component
public class User {
    public void add(){
        System.out.println("add......");
    }
}

@Aspect
@Component
public class UserProxy {
    //前置通知
    @Before(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
    public void before(){
        System.out.println("before......");
    }
}

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.atguigu.spring5.AOPAnnocation"></context:component-scan>
    <!--查看类中是否有@Aspect的注解，如果有就开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

@Aspect
@Component
public class UserProxy {
    //前置通知
    @Before(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
    public void before(){
        System.out.println("before......");
    }
    //最终通知，在方法之后执行,相当于finlly，反正最后一定会执行，出异常了也会执行
    @After(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
    public void after(){
        System.out.println("after.......");
    }
    //后置通知，在返回值之后执行，出异常了就不执行
    @AfterReturning(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
    public void afterReturnning(){
        System.out.println("afterReturnning.....");
    }
    //环绕通知
    @Around(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前");
        proceedingJoinPoint.proceed();//被增强的方法执行
        System.out.println("环绕之后");
    }
    //异常通知，只有当add方法内有异常才会执行
    @AfterThrowing(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
    public void afteraround(){
        System.out.println("AfterThrowing");
    }
}

5.公共切入点抽取

相同的切入点抽取

//增强的类
@Aspect
@Component
public class UserProxy {
    //相同切入点抽取
    @Pointcut(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
    public void pointcut(){

    }
    //前置通知，下面的注解其实就是增强到那个方法上去
    @Before(value = "pointcut()")
    public void before(){
        System.out.println("before......");
    }
    //最终通知，在方法之后执行,相当于finlly，反正最后一定会执行，出异常了也会执行
    @After(value = "pointcut()")
    public void after(){
        System.out.println("after.......");
    }
    //后置通知，在返回值之后执行，出异常了就不执行
    @AfterReturning(value = "pointcut()")
    public void afterReturnning(){
        System.out.println("afterReturnning.....");
    }
    //环绕通知
    @Around(value = "pointcut()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前");
        proceedingJoinPoint.proceed();//被增强的方法执行
        System.out.println("环绕之后");
    }
    //异常通知，只有当add方法内有异常才会执行
    @AfterThrowing(value = "pointcut()")
    public void afteraround(){
        System.out.println("AfterThrowing");
    }
}

6.有多个增强类多同一个方法进行增强，设置增强类优先级

（1）在增强类上面添加注解@order（数字类型值），数字越小，优先级越高。

@Component
@Aspect
@Order(value = 1)
public class PersonProxy {
    @After(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
    public void after(){
        System.out.println("person afetr........");
    }
}

AOP操作（AspectJ配置文件）

1.创建两个类，增强类和被增强类，创建方法。

2.在Spring配置文件中创建两个类对象

3.在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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--创建对象-->
    <bean id="book" class="com.atguigu.spring5.Aspectjxml.Book"></bean>
    <bean id="bookProxy" class="com.atguigu.spring5.Aspectjxml.BookProxy"></bean>
    <!--配置aop增强-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.Aspectjxml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强作用具体在那个方法上-->
            <aop:before method="before" pointcut-ref="p" ></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

SSM整合

参考雷神的整合案例十分详细,个人建议先进行整合再对ssm系统学习,这样可以更加容易的学习

狂神说SpringMVC05：整合SSM框架

程序员？》《

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring（春天）

spring（春天）案例1.新建一个普通java文件2.引入spring的jar包3.创建一个普通类，类中创建普通方法4.创建一个配置文件或者通过注解来创建的那个对象（1）spring配置文件使用xml格式<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http:...
复制链接

扫一扫