Spring

最新推荐文章于 2024-08-04 22:07:39 发布
最新推荐文章于 2024-08-04 22:07:39 发布
阅读量130 收藏
点赞数
分类专栏： 学习 文章标签： spring java java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44623021/article/details/125120242
版权

Spring

Spring概念

轻量级的开源javaEE框架

轻量级，引入的jar包小。不依赖与其他的组件自己可以单独使用。

可以解决开发的复杂性

两个核心

IOC：控制反转，把创建对象过程交给Spring进行管理。

AOP：面向切面，不修改源代码进行功能增强。

Spring特点：

方面结构，简化开发

Aop编程支持

方面程序测试

可以整个其他各种框架。

方便事务操作。

入门案例

Name:spring
Repository Path:release/org/springframework/spring/
URL to file:https://repo.spring.io/artifactory/release/org/springframework/spring/
Created:30-09-19 09:06:32 +00:00
实施：

spring最基本的四个组成部分beans、context、core、expression，这四个基本包。

在使用时需要在增加commons-logging.jar文件；如果没有logging包的话，@test不能使用。

package com.company.testdemo;
import com.company.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpring5 {
//如果没有logging包的话，@test不能使用
    @Test
    public void testAdd(){
        //1 加载spring配置文件
        ApplicationContext context=
                new ClassPathXmlApplicationContext("bean1.xml");
        //2 获取配置创建的对象
        User user=context.getBean("user", User.class);
        System.out.println(user);
        user.add();

    }
}

package com.company;

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

<?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="user" class="com.company.User"></bean>
</beans>

IOC

什么是IOC

控制反转，把对象创建和对象之间的调用过程，交给spring进行管理。使用IOC的目睹是为了耦合度的降低。做的入门案例就是IOC的实现。

IOC的底层原理：

xml解析、工厂模式，反射

说明

当前有两个类分别叫UserService{execute(){}}和UserDao{add(){}},例如当前execute方法要调用add方法，传统的方法是在execute方法中new一个UserDao然后调用add方法，这个方法耦合度太高，如dao的路径变化了execute里面的调用也需要变化。*可以使用工厂模式：再增加一个UserFactory工厂类在工厂类中设置一个public static UserDao getDao(){return new UserDao()};方法。这是在execute方法中可以通过工厂类的getDao方法进行add方法的调用。**但是此时还是有比较高的耦合度的。但是相对于原始方法要好。**而IOC则可以是耦合度更低。

IOC：
IOC过程：

第一步：xml配置文件

<!--    配置User对象创建-->
    <bean id="user" class="com.company.User"></bean>

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

class UserFactory{
    public static UserDao getDao(){
    	String classValue=classs属性值;//1、xml解析
        Class clazz=Class.forName(classsValue);//2 通过反射创建对象
        return (UserDao)clazz.newInstance();
    }
}
IOC接口：

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。Spring提供IOC容器实现两种方式:(两个接口)BeanFactory和ApplicationContext

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

ApplicationContext：BeanFactory接口的子接口，提供更多更强大的接口，提供更多更强大的功能，一般由开发人员进行使用。加载配置文件时候会把在配置文件对象进行创建。在服务器启动的时候就创建，而不是在操作的时候创建。

ApplicationContex接口有实现类。

在这里插入图片描述

IOCbean管理

什么是bean管理：

spring创建对象，spring注入属性。

bean管理有两种操作方式：

基于xml配置文件方式实现。

基于注解方式实现。

IOC操作bean管理
1、基于xml方式创建对象
  1. 在spring配置文件中使用bean标签，标签中添加对应的属性就可以实现对象创建。
  2. 在bean标签中有很多属性：
    1. id属性：给class对象取一个别名以作为唯一的标识
    2. class属性：类的全路径（包类路径）
  3. 创建对象时候默认也是执行无参数构造方法完成对象创建
2、基于xml方式注入属性

  1. DI:以来注入，注入属性。

    1. 使用set方法进行注入

      1. 创建类：定义属性和对应的set方法。

        package com.company;

/**
 * 演示使用set方法进行属性注入
 */
public class Book {
//    public Book(String bname) {
//        this.bname = bname;
//    }
    private String bname;
    private String bauthor;

    public void setBname(String bname) {
        this.bname = bname;
    }
    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

public void testDemo(){
    System.out.printf(bname+"::"+bauthor);
    }
}

      2. 在spring配置文件配置对象创建，配置属性注入

        <!--    set方法注入属性-->
    <bean id="book" class="com.company.Book">
<!--        使用property完成属性注入
            name：类里面属性名称
            value：像属性注入的值-->
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>
    </bean>

      3. 测试

        @Test
public void testBook1(){
    //1 加载spring配置文件
    ApplicationContext context=
            new ClassPathXmlApplicationContext("bean1.xml");
    //2 获取配置创建的对象
    Book book=context.getBean("book", Book.class);
    System.out.println(book);
    book.testDemo();
}

      有参构造注入（快捷键alt+ins）

    2. 在spring配置文件中进行配置

      <!--    有参数构造注入属性-->
    <bean id="orders" class="com.company.Orders">
        <constructor-arg name="oname" value="abc"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>

  2. p名称空间注入(了解)

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

      1. 第一步；添加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标签中进行操作

        <bean id="book" class="com.company.Book" p:bname="九阳神功" p:bauthor="无名氏"></bean>
3、IOC操作bean管理（xml注入其他类型属性）

  1. 字面量：null值

        <bean id="book" class="com.company.Book">
<!--        使用property完成属性注入
            name：类里面属性名称
            value：像属性注入的值-->
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>
<!--        null值-->
        <property name="address"><null/></property>
    </bean>

  2. 注入属性外部bean

    1. 创建两个类service类和dao类。

      package com.company.dao;

public class UserDaoImpl implements UserDao {

    @Override
    public void upadd() {

        System.out.println("dao updata...........");
    }
}

    2. 在service调用到里面的方法。

      package com.company.service;

import com.company.dao.UserDao;
import com.company.dao.UserDaoImpl;

public class UserService {

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

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

        userDao.upadd();

//原始方式：创建UserDao对象
//        UserDao userDao = new UserDaoImpl();
//        userDao.upadd();
    }
}

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

    <!--service和dao对象创建-->
    <bean id="userService" class="com.company.service.UserService">
<!--        注入userDao对象
            name属性值：类里面属性名称
            ref属性：创建userDao对象备案标签id值-->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>

    <bean id="userDaoImpl" class="com.company.dao.UserDaoImpl"></bean>

</beans>

      测试

      @Test
    public void testAdd(){
        //1、加载spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");
        //2、获取配置创建的对象
        UserService userService=context.getBean("userService", UserService.class);
        userService.add();
    }

  3. 注入属性-内部bean

    1. 一对多关系：部门和员工

      package com.company.bean;
/**
 * 部门类
 */
public class Dept {
    private String dname;

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

    2. 一个部门有多个员工一个员工属于一个部门。部门是一，员工是多

      package com.company.bean;

/**
 * 员工类
 */
public class Emp {
    private String ename;
    private String genter;
//员工属于某一个部门，使用对象形式表示
    private Dept dept;
    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGenter(String genter) {
        this.genter = genter;
    }

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

    public void add(){
        System.out.printf(ename+"::"+genter+"::"+dept);
    }
}

    3. 在实体类之间表示一对多关系

    4. 在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-->
    <bean id="emp" class="com.company.bean.Emp">
<!--        设置两个普通属性对象-->
        <property name="ename" value="lucy"></property>
        <property name="genter" value="nv"></property>
<!--        设置对象类型属性-->
        <property name="dept">
            <bean id="dept" class="com.company.bean.Dept">
                <property name="dname" value="保安部"></property>
            </bean>
        </property>
    </bean>
</beans>

      测试

      @Test
public void testBean3(){
    //1、加载spring配置文件
    ApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
    //2、获取配置创建的对象
    Emp emp = context.getBean("emp",Emp.class);
    emp.add();
}

  4. 注入属性：级联赋值

    更改Spring配置文件

    1. 写法1

      <!--    内部bean-->
<bean id="emp" class="com.company.bean.Emp">
    <!--        设置两个普通属性对象-->
    <property name="ename" value="lucy"></property>
    <property name="genter" value="nv"></property>
    <!--        设置对象类型属性-->
    <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.company.bean.Dept"><property name="dname" value="财务部"></property> </bean>

    2. 写法二：需要在emp类中增加getdept方法

      <!--    级联赋值-->
<bean id="emp" class="com.company.bean.Emp">
    <!--        设置两个普通属性对象-->
    <property name="ename" value="lucy"></property>
    <property name="genter" value="nv"></property>
    <!--        设置对象类型属性-->
    
    <property name="dept.dname" value="jishubu"></property>

</bean>

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

public Dept getDept() {
    return dept;
}
4、IOC操作bean管理（xml注入集合属性）

  1. 注入数组类型属性

    注入list集合类型属性

    注入Map集合类型属性

    1. 创建类，定义数组、list、map、set类型属性，生成对应set方法

      package com.company.collectiontype;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

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

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

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);


    }
}

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


<!--    1集合类型属性注入-->
    <bean id="stu" class="com.company.collectiontype.Stu">
<!--        数组类型注入-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>SQL</value>

            </array>
        </property>
<!--        list类型注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>
<!--        map类型属性注入-->
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <!--        set类型属性注入-->
        <property name="sets">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
    </bean>

</beans>

      测试

      package com.company.testdemo;

import com.company.collectiontype.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5Demo1 {

    @Test
    public void testCollection(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        Stu stu=context.getBean("stu",Stu.class);
        stu.test();
    }
}

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

    <!--        注入list集合类型，值是对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
        
    </bean>



    <bean id="course1" class="com.company.collectiontype.Course">
        <property name="cname" value="Spring5框架课程"></property>
    </bean>
    <bean id="course2" class="com.company.collectiontype.Course">
        <property name="cname" value="MyBatis框架课程"></property>
    </bean>

  3. 把集合注入部门提取出来

    1. 在spring配置文件中引入名称空间：util

      <?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"
       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/beans/spring-util.xsd">
5、IOC操作bean管理(FactoryBean)

  1. Spring有两种类型bean，一种普通bean，另一种工厂bean（FactoryBean）

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

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

      1. 创建类，让这个类作为工厂bean，实现接口FactoryBean

        package com.company.factorybean;

import com.company.collectiontype.Course;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean<Course>{

    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course= new Course();
        course.setCname("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

}

      2. 实现接口里面的方法，在实现的方法中定义返回的bean类型

        <bean id="myBean" class="com.company.factorybean.MyBean"></bean>

        @Test
public void testCollection3(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
    Course course=context.getBean("myBean", Course.class);
    System.out.println(course);
}
6、IOC操作Bean管理（bean作用域）

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

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

    @Test
public void testCollection2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
    Book book1 = context.getBean("book",Book.class);
    Book book2 = context.getBean("book",Book.class);
    //book.test();
    System.out.println(book1);
    System.out.println(book2);
}

    输出结果：

    com.company.collectiontype.Book@7d20d0b
    com.company.collectiontype.Book@7d20d0b

  3. 如何设置单实例还是多实例

    1. 在spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例

    2. scope属性值

      1. 默认值：singleton，表示是单实例对象
      2. prototype，表示的是多实例对象

      代码：

      <!--    2 提取list集合类型属性注入使用-->
    <bean id="book" class="com.company.collectiontype.Book" scope="prototype">
        <property name="list" ref="booklist"></property>
    </bean>

      输出结果：

      com.company.collectiontype.Book@7d20d0b
      com.company.collectiontype.Book@77f1baf5

    3. singleton和prototype区别：

      1. singleton单实例，prototype多实例

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

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

7、IOC操作Bean管理（Bean生命周期）

  1. bean生命周期：

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

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

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

    4. bean可以使用了（对象获取到了）

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

          @Test
    public void test4(){
//        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
//        Orders orders=context.getBean("orders", Orders.class);
//        System.out.println("fouth 获取创建bean实例对象");
//        System.out.println(orders);
//        //手动让bean实例销毁
//        ((ClassPathXmlApplicationContext)context).close();
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders=context.getBean("orders", Orders.class);
        System.out.println("fouth 获取创建bean实例对象");
        System.out.println(orders);
        //手动让bean实例销毁
        context.close();

    }

      package com.company.bean;

public class Orders {

    public Orders() {
        
        System.out.println("first 执行无参数构造创建bean实例");
    }

    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("second 调用set方法设置属性值");
    }

    public void initMethod(){
        System.out.println("third 执行初始化的方法");
    }

    public void destoryMethod(){
        System.out.println("fifth 执行销毁的方法");
    }
}

      <bean id="orders" class="com.company.bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
    <property name="oname" value="youji"></property>
</bean>

  2. bean的后置处理器，bean生命周期有七步

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

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

    3. 把bean实例传递bean后置处理器的方法 postProcessBeforeInitialization

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

    5. 把bean实例传递bean后置处理器的方法 postProcessAfterInitialization

    6. bean可以使用了（对象获取到了）

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

      package com.company.bean;

public class Orders {

    public Orders() {
        
        System.out.println("first 执行无参数构造创建bean实例");
    }

    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("second 调用set方法设置属性值");
    }

    public void initMethod(){
        System.out.println("third 执行初始化的方法");
    }

    public void destoryMethod(){
        System.out.println("fifth 执行销毁的方法");
    }
}

      package com.company.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;


public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("把bean实例传递bean后置处理器的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("把bean实例传递bean后置处理器的方法");
        return bean;
    }
}

      <bean id="orders" class="com.company.bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
    <property name="oname" value="youji"></property>
</bean>

<bean id="myBeanPost" class="com.company.bean.MyBeanPost"></bean>

      @Test
public void test5(){

    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
    MyBeanPost myBeanPost=context.getBean("myBeanPost", MyBeanPost.class);
    System.out.println("fouth 获取创建bean实例对象");
    System.out.println(myBeanPost);
    //手动让bean实例销毁
    context.close();
}
8、IOC操作Bean管理（XML自动装配）
  1. 什么是自动装配

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

  2. 演示过程，两者同理，不能有两个相同的类型

    <!--实现自动装配
bean标签autowire;配置自动床配
有两个属性值：
byName：根据属性名称注入，注入值bean的id值和类属性名称一样
byType：根据类型名称注入
-->
    <bean id="emp" class="com.company.autowire.Emp" autowire="byName" >
    </bean>
    <bean id="dept" class="com.company.autowire.Dept"></bean>
</beans>

    @Test
public void test6(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
    Emp emp=context.getBean("emp", Emp.class);

    System.out.println(emp);


}
9、IOC操作bean管理（外部属性文件）

  1. 直接配置数据库信息

    1. 配置德鲁伊连接池

    2. 引入德鲁伊连接池依赖jar包

      druid-1.2.9.jar

      <!--直接配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mydql://localhost:3306/userDb"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

  2. 外部属性文件配置数据库连接池

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

      prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql;//3306/userDb
prop.name=root
prop.password=root

      <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <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.name}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>
10、IOC操作Bean管理（基于注解方式）

  1. 什么是注解

    1. 注解是代码特殊标记，格式：@注解名称（名称属性=属性值，属性名称=属性值…
    2. 使用注解，注解作用在类上面，方法上面，属性上面
    3. 使用注解目的：简化xml配置。

  2. Spring 针对bean管理中创建对象提供注解

    1. @Component
    2. @Service
    3. @Controller
    4. @Repository
    5. 以上实例可以来创建Bean实例

  3. 基于注解方式实现对象创建

    1. 引入依赖spring-aop.jar

    2. 开启组件扫描

      /**
 * 在注解里面value属性值可以省略不屑，默认值是类名称，首字母小写
 * UserService——userService
 */
@Component(value = "userService")
public class UserService {
    public void add(){
        System.out.println("service add...");
    }
}

          @Test
    public void testCollection1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService=context.getBean("userService",UserService.class);
        userService.add();
        System.out.println(userService);
    }
}

      <?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.company"></context:component-scan>
</beans>
      11、基于注解方式实现属性注入

      1. @Autowired：根据属性类型进行自动装配

        /**
 * 在注解里面value属性值可以省略不屑，默认值是类名称，首字母小写
 * UserService——userService
 */
@Service
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解

    @Autowired//根据类型进行注入
    
    
    public void add(){
        System.out.println("service add...");
        userDao.add();
    }
}

        public class UserDao{

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

    }
}

            @Test
    public void testCollection1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService=context.getBean("userService",UserService.class);
        userService.add();
        System.out.println(userService);
    }
}

        <!--    开启组件扫描 如果扫描多个包，多个包使用逗号隔开 扫描包上层目录-->
    <context:component-scan base-package="com.company"></context:component-scan>

      2. @Qualifier：根据属性名称进行注入 Qualifier要和Autowired一起使用

        package com.company.testdemo.dao;

public interface UserDao {
    public void add();
}

        package com.company.testdemo.dao;

import org.springframework.stereotype.Repository;

@Repository(value = "userDaoImpl111")
public class UserDaoImpl implements UserDao{

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

    }
}

        package com.company.testdemo.service;

import com.company.testdemo.dao.UserDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;


/**
 * 在注解里面value属性值可以省略不屑，默认值是类名称，首字母小写
 * UserService——userService
 */
@Service
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解

    @Autowired//根据类型进行注入
    @Qualifier(value = "userDaoImpl111")//Qualifier要和Autowired一起使用
    private UserDaoImpl userDao;
    public void add(){
        System.out.println("service add...");
        userDao.add();
    }
}

        <!--    开启组件扫描 如果扫描多个包，多个包使用逗号隔开 扫描包上层目录-->
    <context:component-scan base-package="com.company"></context:component-scan>

        public class TestSpring5Demo1 {

    @Test
    public void testCollection1(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService=context.getBean("userService",UserService.class);
        userService.add();
        System.out.println(userService);
    }
}

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

        package com.company.testdemo.dao;

public interface UserDao {
    public void add();
}

        package com.company.testdemo.dao;

import org.springframework.stereotype.Repository;

@Repository(value = "userDaoImpl111")
public class UserDaoImpl implements UserDao{

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

    }
}

        package com.company.testdemo.service;

import com.company.testdemo.dao.UserDao;
import com.company.testdemo.dao.UserDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;


/**
 * 在注解里面value属性值可以省略不屑，默认值是类名称，首字母小写
 * UserService——userService
 */
@Service
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解

//    @Autowired//根据类型进行注入
//    @Qualifier(value = "userDaoImpl111")//Qualifier要和Autowired一起使用
//    private UserDaoImpl userDao;

    //@Resource这个注解位于import javax.annotation.Resource;这个包
    //@Resource//根据类型注入
    @Resource(name = "userDaoImpl111")
    private UserDao userDao;

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

        @Test
public void testCollection1(){
    ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
    UserService userService=context.getBean("userService",UserService.class);
    userService.add();
    System.out.println(userService);
}

        <!--    开启组件扫描 如果扫描多个包，多个包使用逗号隔开 扫描包上层目录-->
    <context:component-scan base-package="com.company"></context:component-scan>

      4. @Value：普通类型属性值的注入

        //service层
@Value(value = "abc")
private String name;

    3. 完全注解开发

      1. 创建配置类，替代xml配置文件

        package com.company.testdemo.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration//作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.company"})
public class SpringConfig {

}


        @Test
public void testService2(){
    ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService=context.getBean("userService",UserService.class);
    userService.add();
    System.out.println(userService);
}

AOP

1、什么是AOP

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

不通过修改源代码方式添加新功能而是通过权限判断模块。

2、AOP原理

package com.company.testdemo;

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

package com.company.testdemo;



public class UserDaoImpl implements UserDao {

    @Override
    public int add(int a, int b) {
        return a+b;
    }

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

package com.company.testdemo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces={UserDao.class};
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                return null;
//            }
//        });
        UserDaoImpl userDao=new UserDaoImpl();
        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
    }
}
//创建代理对象
class UserDaoProxy implements InvocationHandler{

    //1、把创建的是是谁的代理对象把谁传递过来
    //有参构造
    Object obj;
    public UserDaoProxy(Object obj)
    {
        this.obj=obj;
    }
    //蹭墙的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //方法之前
        System.out.println("before："+method.getName()+":Parameter:"+ Arrays.toString(args));

        //被增强的方法执行
        Object res=method.invoke(obj,args);

        //方法之后
        System.out.println("after..."+obj);
        return res;
    }
}

JDBC Template

事务管理

Spring新特性

正在努力的软工小白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 8万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
《滚雪球学Spring Boot》教程导航帖（更新于2024.06.20）
**My Coding Family**
06-29 4万+
《滚雪球学Spring Boot》是由CSDN博主bug菌创作的全面Spring Boot教程。作者是全栈开发专家，在多个技术社区如CSDN、掘金、InfoQ、51CTO等担任博客专家，并拥有超过30万的全网粉丝。该教程分为入门篇和进阶篇，每篇包含详细的教学步骤，涵盖Spring Boot的基础和高级主题。
微服务架构Spring Cloud概述和基本讲解
张彦峰的博客
02-14 164万+
微服务架构Spring Cloud概述和基本讲解
Spring Boot面试题（2020最新版）
ThinkWon的博客
02-19 56万+
文章目录概述什么是 Spring Boot？Spring Boot 有哪些优点？Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？配置什么是 JavaConfig？Spring Boot 自动配置原理是什么？你如何理解 Spring Boot 配置加载顺序？什么是 YAML？YAML 配置的优势在哪里 ?Spring Boot 是否可以使用 XML 配置 ?spring boot......
【Spring】一个spring简单实例
一定要站在自己热爱的生活里闪闪发光
05-07 7万+
spring的基础知识就不讲了，直接上代码吧！ 为了方便大家创建文件，先把project的结构放在这 1.新建一个projec，本帖设置的名字为“project-hello”. 2. 新建一个package，这里取名为“com.company.project”. 3. 新建一个class，名为“Hello”。代码为： package com.company.project; public class Hello { private String name; pub.
史上最简单的 SpringCloud 教程 | 终章
热门推荐
方志朋的专栏
04-12 197万+
转载请标明出处： http://blog.csdn.net/forezp/article/details/70148833 本文出自方志朋的博客 错过了这一篇，你可能再也学不会 Spring Cloud 了！Spring Boot做为下一代 web 框架，Spring Cloud 作为最新最火的微服务的翘楚，你还有什么理由拒绝。赶快上船吧，老船长带你飞。终章不是最后一篇，它是一个...
Spring Boot源码解读与原理分析
herosunly的博客
10-17 5万+
最近机缘巧合之下，读到了LinkedBear编写的《Spring Boot源码解读与原理分析》这本书，本人花了一周的时间认真研读了一下这本书，真的是受益匪浅，特此推荐给大家，好书不容错过啊。 文章目录 1. 关于作者 2. 本书定位 3. 目标读者 4. 读后感受 5. 书籍特点 6. 总结与展望 LinkedBear是一名资深的Java开发工程师，他倾力研究Spring技术体系多年，对Spring、Spring Boot、MyBatis等框架有独到的见解，拥有丰富的框架体系实践经验和架构封装经验。
Spring入门第一讲——Spring框架的快速入门
李阿昀的博客
04-08 14万+
Spring的概述什么是Spring据度娘所载： Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。 Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Exp
如何搭建Spring源码阅读项目，基于5.2.x版本
scoful的专栏
09-23 6万+
目录1. 唠叨两句2. 查看源码的gradle版本3. 下载源码3.1 源码地址3.2 通过gitee中转3.2.1 进去github源码地址，复制URL3.2.2 进入gitee，选择右上角加号，选择从GitHub/GitLab导入仓库3.2.3 粘贴复制的github地址到第一栏,然后为自己的仓库命名3.2.4 下载gitee代码到本地文件夹中3.2.4.1 选择稳定的5.2.x版本，复制地址3.2.4.2 命令行下载源码到本地文件夹4. 加载进IDEA4.1 IDEA操作:File--> OPE
Spring——Spring整合MyBatis
★★光亭★★
03-13 2万+
Spring——Spring整合MyBatis
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
spring-ai-core 0.8.1
05-21
《Spring AI Core 0.8.1：开启人工智能之旅》 在现代软件开发领域，Spring框架以其强大的功能和灵活性，已经成为Java开发中的首选框架之一。而Spring AI Core则是Spring生态系统中专门为人工智能（AI）和机器学习...
springcloud源码
08-13
Spring Cloud 是一个基于 Spring Boot 实现的微服务框架，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态）操作的...
SpringMVC+Spring+Mybatis集成开发环境
04-28
在IT行业中，SpringMVC、Spring和Mybatis是三大核心框架，它们的集成使用是Java Web开发中的常见实践。这个集成开发环境旨在提供一个高效、灵活的开发平台，以实现业务逻辑与数据访问的分离，提高代码的可维护性和可...
spring jar包
08-05
spring-aop-3.2.2.RELEASE.jar spring-beans-3.2.2.RELEASE.jar spring-context-3.2.2.RELEASE.jar spring-context-support-3.2.2.RELEASE.jar spring-core-3.2.2.RELEASE.jar spring-data-commons-1.5.0.RELEASE....
从根儿上学习spring 九 之run方法启动第四段(3)
最新发布
baidu_19338587的博客
08-04 495
一般情况下调用doGetBean方法获取的bean实例都是为了真实使用的，像我们上面举得A，B对象的例子获取的A，B对象当然都是为了真实使用的，但有种场景就只是为了做类型检查，比如有时候为了判断FactoryBean里的对象的类型就要先获取FactoryBean再通过getObject方法获取里面的真实对象来判断其类型，这时获取的FactoryBean实例可能就只是为了类型检查并不是为了真实使用。二:当bean是多例时，会有不同的创建bean的逻辑，下面我们按照代码顺序先分析单例的情况。
springcloud和springboot版本对照表
qq_43071699的博客
08-04 230
Spring Cloud 的版本命名采用了伦敦地铁站名的方式，例如 Greenwich、Hoxton、2020.0.0 等，每个版本都有一个对应的 Spring Boot 和其他依赖的兼容版本范围。Spring Cloud 的版本通常与 Spring Boot 和其他依赖库的版本保持一致，以确保兼容性和稳定性。在实际项目中，通常推荐使用最新稳定版本的 Spring Cloud 和 Spring Boot，以获得最新的功能和最佳的安全性和性能。
Spring Task初学
2301_79693537的博客
08-04 61
Spring Task 是Spring框架提供的任务调度工具，可以按照约定的时间自动执行某个代码逻辑
Spring MVC 之简介及常见注解
m0_60462557的博客
08-04 182
Spring Web MVC 是基于 Servlet API 构建的原始 Web 框架，从一开始就包含在 Spring 框架中。它的正式名称 “Spring Web MVC” 来自其源模块的名称 (Spring-webmvc)，但它通常被称为"Spring MVC"。
Spring实践指南
"Spring in Practice" 是一本关于Spring框架的实践指南，类似于"Spring in Action"，适合有一定英文基础的读者阅读。本书由Willie Wheeler和Joshua White合作撰写，覆盖了Spring 3版本的内容。 在Spring框架的实践...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值