Spring回顾-IOC（万字从0到1教你spring注解开发方式）

最新推荐文章于 2024-08-16 20:21:37 发布
最新推荐文章于 2024-08-16 20:21:37 发布
阅读量667 收藏 12
点赞数 22
分类专栏： 项目——SSM 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62569064/article/details/141004098
版权

1.Spring框架介绍：

Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。

Spring可以去整合表现层，业务层，持久层的开源的框架，在表现层提供了与Struts2框架的整合，在业务逻辑层可以管理事务和记录日志，在持久层可以整合Hibernate和JdbcTemplate等技术。

框架的主要优势之一就是分层架构，分层架构允许使用者选择哪一个组件。

Spring的核心就是控制反转（IOC控制反转）和面向切面AOP。

1.1 Spring的优点

1.方便解耦，简化开发，Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理。IOC的作用。

2.AOP编程的支持，Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。（可扩展性）

3.声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编程。

有两种实现方式：一种是动态代理，一种是静态代理

4.方便程序的测试，Spring对Junit4支持，可以通过注解方便的测试Spring程序。

5.方便集成各种优秀框架，Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts2、Hibernate、MyBatis、Quartz等）的直接支持。

6.降低JavaEE API的使用难度，Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低。

2. Spring—IOC

2.1 什么是IOC

IOC——Inverse of Control ，控制反转，将对象的创建权力反转给Spring框架！！

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

Spring工厂读取配置文件

2.2 写一个IOC程序

首先我们创建一个Java maven的项目

在项目src目录下的main目录中的java目录下随便创建一个目录然后在该目录下创建一个service的包，包中写一个接口

public interface UserService {
    public void  hello();
}

再写一个接口实现类

public class UserServiceImpl implements UserService {
    @Override
    public void hello() {
        System.out.println("IOC!!!");
    }
}

然后去test下写一个测试类测试一下

public class test {
    @Test
    public void run(){
        UserService userService= new  UserServiceImpl();
        userService.hello();

    }
}

ok了

如果我们没有IOC（控制反转）就需要向上面一样自己手动new一个对象去实现这个hello方法。

如果我们要实现IOC（控制反转）该怎么做？

首先，编写Spring核心的配置文件，在src目录下创建applicationContext.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">
    
    <!--IOC管理bean-->
    <bean id="userService" class="com.qcbyjy.service.UserServiceImpl" />
    
</beans>

然后引入一个标签，该标签有两个属性一个id 一个class，id就是你给这个对象起的名字，class就是你的这个类的所在的位置。

在spring的配置文件中配置一个bean，就相当于把这个类交给Spring的IOC容器去管理，Spring管理的对象叫做bean对象。

然后在测试类里写一个测试方法

@Test
public void run1(){
    //spring的工厂对象 bean工厂
    //去读取spring的配置文件
    //Spring 的工厂是负责加载并管理所有的
    ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");
    //工厂对象的方法
    UserService userService= (UserService) ac.getBean("userService");
    //调用userService实现的方法
    userService.hello();

}

我们来看一下这Application这个接口，这个接口最下面有两个实现类，一个ClassPathXmIApplicaitonContext（加载类路径下的配置文件），一个是FileSystemXmlAppcationContext（就是直接把配置文件的地址写上）

2.3 两种创建方式的对比

自己new对象

@Test
public void run(){
    UserService userService= new  UserServiceImpl();
    UserService userService1= new  UserServiceImpl();
    System.out.println(userService);
    System.out.println(userService1);

}

工厂创建对象的方式

@Test
public void run1(){
    //spring的工厂对象 bean工厂
    //去读取spring的配置文件
    //Spring 的工厂是负责加载并管理所有的
    ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");
    //工厂对象的方法
    UserService userService= (UserService) ac.getBean("userService");
    UserService userService1= (UserService) ac.getBean("userService");
    //调用userService实现的方法
    System.out.println(userService);
    System.out.println(userService1);
}

我们会发现工厂创建的是同一对象，就是说在不做任何改变的情况下，我们使用spring的工厂创建对象的时候，默认的是单例模式。

2.4 Spring框架的Bean管理的配置文件方式 

class属性，Bean对象的全路径。

scope属性，scope属性代表Bean的作用范围。

 singleton单例（默认值），最常用的方式。

​ prototype多例

​ request应用在Web项目中,每次HTTP请求都会创建一个新的Bean

​ session应用在Web项目中,同一个HTTP Session 共享一个Bean

Bean对象的创建和销毁的两个属性配置

说明：Spring初始化bean或销毁bean时，有时需要作一些处理工作，因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方法

init-method:当bean被载入到容器的时候调用init-method属性指定的方法

destroy-method:当bean从容器中删除的时候调用destroy-method属性指定的方法

单例对象的销毁：随着容器工厂的销毁而销毁

多例对象的销毁：垃圾回收机制进行回收

所以这个destroy-method的方法我们没法看到，只能看一下init_method的实现。

首先，在UserServiceImpl类下的写一个init的方法。

/**
 * 对象被创建前的初始化的方法
 */
public void init(){
    System.out.println("init方法的执行");
}

        指定初始化的方法，然后我们去测试一下效果        

public void run1(){
        //spring的工厂对象 bean工厂
        //去读取spring的配置文件
        //Spring 的工厂是负责加载并管理所有的
        ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");
        //工厂对象的方法
        UserService userService= (UserService) ac.getBean("userService");
        userService.hello();
    }

        这个初始化方法在单例和多例模式下运行的时机不太一样，也可以说单例和多例模式下创建对象的时机是不一样的。

        我们来看一下：

       先在创建工厂对象下加一行分隔符

        然后在单例模式(默认)下运行看一下，

        我们可以看到在单例模式在创建工厂的时候就把对象也给创建了。

        多例模式下再运行看一下

        就会发现我们多例模式下，是创建完工厂后，当需要创建对象时才会创建对象，进行初始化。

2.5 Spring实例对象的三种方式

默认

无参数的构造方法（基本上都是默认）

<bean id="userService" class="com.qcby.service.UserServiceImpl"/>

静态工厂实例化

使用静态工厂实例化，首先要去写一个静态的工厂类

/**
 * 利用静态工厂的方法创建对象
 */
public class StaticFactory {
    public static UserService createUseService(){
        System.out.println("通过静态工厂的方式创建对象");
        return new UserServiceImpl();
    }
}

        然后我们去application.xml的配置文件中，配置该对象

        

<bean id="userServiceFactory" class="com.qcby.Factory.StaticFactory" factory-method="createUseService" />

        主要的就是在最后指定一下调用的静态工厂的方法，然后我们来测试一下。

@Test
public void run3(){
    //创建工厂对象
    ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");

    UserService userService = (UserService) ac.getBean("userServiceFactory");

    userService.hello();
}

实例工厂实例化

        再来说一下工厂实例化的过程，所谓的工厂 实例化就需要我们去创建一个普通的工厂类，然后再写一个创建对象的方法。

public class UserFactory {
    public UserService createUserService1(){
        System.out.println("通过工厂实例化的方法去创建对象");
        return new UserServiceImpl();
    }
}

        因为这个类是一个普通的类，无法直接调用该类中的方法，所以，我们再配置文件中，需要配置一个工厂类，这样才能调用到里面的方法。

<bean id="factory" class="com.qcby.Factory.UserFactory" />
<bean id="userService" factory-bean="factory" factory-method="createUserService1" />

        写一个测试类

/**
 * 实例工厂的方式获取bean对象
 */
@Test
public void run4(){
    ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");

    UserFactory userFactory =(UserFactory) ac.getBean("factory");
    UserService userService = (UserService) ac.getBean("userServiceFactory");

    userService.hello();
}

3. DI注入

3.1 什么是DI注入

IOC和DI的概念

​ IOC：Inverse of Control，控制反转，是一种思想，将对象的创建权反转给Spring！！

​ DI：Dependency Injection，依赖注入，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中！！

简单的举个例子，

我们先写一个Student的类

public class Student {

    private String name;

    private Integer age;

    private String classname;

    public Student() {
    }

    public Student(String name, Integer age, String classname) {
        this.name = name;
        this.age = age;
        this.classname = classname;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getClassname() {
        return classname;
    }

    public void setClassname(String classname) {
        this.classname = classname;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", classname='" + classname + '\'' +
                '}';
    }
}

        然后使用默认方法构建对象

<bean id="student" class="com.qcby.model.Student"/>

        测试方法

@Test
public void run5(){
    ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");

    Student student=(Student) ac.getBean("student");

    System.out.println(student);
}

        然后我们会发现我们创建的类没有值

        那我们试如何给对象的属性注入值呢？

        以前没有学Spring的时候，我们有两种方式，一种Set方法，一种是构造器。

Student student1=new Student();
//set方法
student1.setName("zhangsan");
student1.setAge(18);
student1.setClassname("bigdata");
System.out.println(student1);
//构造器
Student student2=new Student("lisi",21,"bigdata");
System.out.println(student2);

        当我们有了Spring之后就可以不用这么做了，那么我们该如何做呢 ？

        也是分两种方式：

        Set方法注入和构造器注入

        我们首先先创建一个OrderService的接口，里面有一个保存订单的方法

public interface OrderService {
    
    public void saveOrder();
}

        再写一个OrderServiceImpl的实现类

public class OrderServiceImpl implements OrderService{
    @Override
    public void saveOrder() {
        System.out.println("业务层保存订单！！！");
    }
}

        我们一般业务层要调用持久层的方法，所以我们去创建一个OrderDao的接口和一个OrderDaoImpl的实现类

public interface OrderDao {

    public void saveOrder();
}
public class OrderDaoImpl implements OrderDao{
    @Override
    public void saveOrder() {
        System.out.println("持久层保存订单");
    }
}

        然后我们去application.xml中配置文件配置        

3.2 set方法注入

<bean id="orderDao" class="com.qcby.dao.OrderDaoImpl"/>
<bean id="orderService" class="com.qcby.service.OrderServiceImpl">
    <property name="orderDao" ref="orderDao"/>
    <property name="name" value="张三"/>
    <property name="Account" value="18" />
</bean>

3.3 构造器方法注入

<bean id="student" class="com.qcby.model.Student">
    <constructor-arg name="name" value="李四"/>
    <constructor-arg name="age" value="18"/>
    <constructor-arg name="classname" value="bigdata"/>
</bean>
Student student=(Student) ac.getBean("student");

System.out.println(student);

3.4 数组、集合、properties的注入

        首先去创建一个类，类里面写一个数组，然后写一个set方法，并重写一个toString的方法

public class CollectionBean {
    private String[] strs;

    private List<String> list;

    private Map<String,String> map;

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

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

    public void setStrs(String[] strs) {
        this.strs = strs;
    }

    @Override
    public String toString() {
        return "CollectionBean{" +
                "strs=" + Arrays.toString(strs) +
                ", list=" + list +
                ", map=" + map +
                '}';
    }
}

        然后去application.xml的文件中注入值

<bean id="collectionBean" class="com.qcby.model.CollectionBean">
    <property name="strs">
        <array>
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
        </array>
    </property>
    <property name="list">
        <!-- 这个地方用list也行 -->
        <list>
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
        </list>
    </property>
    <property name="map">
        <map>
            <entry value="a"  key="张三"/>
            <!-- 如果是引用数据类型可以使用key-ref="" value-ref="" -->
            <entry value="b" key="李四"/>
        </map>
    </property>
</bean>

        写一个测试方法测试一下

@Test
public void run7(){
    ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");

    CollectionBean collectionBean=(CollectionBean) ac.getBean("collectionBean");

    System.out.println(collectionBean);

}

        唯一有点不同的就是properties

<property name="properties">
     <props>
        <prop key="username">root</prop>
         <prop key="password">123456</prop>
    </props>
</property>

3.5 多配置文件形式

就是我们感觉写在一文件里面太麻烦了，想要在多个文件中写，行不行？

当然可以了，我们有两种方式可以进行多文件的配置，接下来我们演示一下多文件配置的方式，先把第一个application中的student注释掉。

然后我们会发现再使用工厂对象创建Student的对象就不行了

然后我们去resources下创建一个application01.xml的文件，把Student类交给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="student" class="com.qcby.model.Student">
        <constructor-arg name="name" value="李四"/>
        <constructor-arg name="age" value="18"/>
        <constructor-arg name="classname" value="bigdata"/>
    </bean>
</beans>

        然后再创建工厂对象的时候使用写两个配置文件

ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml","application01.xml");

        再运行的时候就可以了

        还有一种方式就是：我不在创建工厂对象的时候写两个配置文件

ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");

        我们可以在 application文件中用标签，引入其他的文件，也是可以的

<import resource="application01.xml"/>

4. Spring-IOC开发中的实际应用（demo）

4.1 创建数据库

创建一个数据库

create database spring_db;
use spring_db;
create table account(
    id int primary key auto_increment,
    name varchar(40),
    money double
)character set utf8 collate utf8_general_ci;

        向里面插入几条数据

insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);

4.2 创建项目

4.2.1 创建一个JavaMaven的项目

上面有提到过，忘记的往上翻一下

4.2.2 导入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--连接池-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.10</version>
    </dependency>
    <!-- mysql驱动包 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
</dependencies>

4.3 创建dao和service的演示类

        创建实体类（Account）

public class Account {

    private Integer id;

    private String name;

    private Integer money;

    public Account() {
    }

    public Account(Integer id, String name, Integer money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getMoney() {
        return money;
    }

    public void setMoney(Integer money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

        创建Dao的接口

public interface AccountDao {
    public List<Account> SelectAll();
}

        Dao层的实现类

public class AccountDaoImpl implements AccountDao{

    @Override
    public List<Account> SelectAll() {

        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_db");
        dataSource.setUsername("root");
        dataSource.setPassword("password");

        List<Account> list=new ArrayList<Account>();

        Connection connection=null;
        PreparedStatement statement= null;
        ResultSet resultSet=null;


        try {
            //获取连接
            connection=dataSource.getConnection();
            //编写sql语句
            String sql="SELECT * FROM `account`";
            //预编译
            statement = connection.prepareStatement(sql);
            //查询
            resultSet=statement.executeQuery();
            // 遍历封装数据
            while(resultSet.next()){
                Account account =new Account();
                account.setId(resultSet.getInt("id"));
                account.setName(resultSet.getString("name"));
                account.setMoney(resultSet.getInt("money"));
                list.add(account);

            }

        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try{
                connection.close();
            }catch (SQLException e){
                e.printStackTrace();
            }
            try{
                statement.close();
            }catch (SQLException e){
                e.printStackTrace();
            }
        }
        return list;
    }
}

        然后创建Service层的接口

public interface AccountService {

    public List<Account> selectAll();

}

        Service的实现类

public class AccountServiceImpl implements AccountService{
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> selectAll() {
        return accountDao.SelectAll();
    }
}

        application.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">
    <bean id="accountService" class="com.qcby.service.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <bean id="accountDao" class="com.qcby.dao.AccountDaoImpl"/>

</beans>

        最后测试

public class Demo1 {

    @Test
    public void run1(){
        ApplicationContext ac= new ClassPathXmlApplicationContext("application.xml");

        AccountService accountService=(AccountService) ac.getBean("accountService");

        List<Account> accounts=new ArrayList<Account>();

        accounts=accountService.selectAll();
        System.out.println(accounts);
    }
}

5. 注解开发的方式

5.1 半注解半配置文件的形式

我们先来创建一个类UserService的接口

public interface UserService {

    public void hello();

}

           在写一个实现类         

/**
 * SpringIOC半配置文件半注解的形式
 * @Component(value="")这个注解就相当于<bean id="userService" class="com.qcby.service.UserServiceIpml"/>
 * value就是相当于id，如果不写value就是把类名的首字母小写作为id
 *
 */
 
@Component(value = "userService")
public class UserServiceIpml implements UserService{
    @Override
    public void hello() {
        System.out.println("SpringIOC,半注解半配置文件的形式");
    }
}

        如果我们按照上文所学的知识就是在application中写写这么一个标签将这个类交给Spring去管理，但是我们现在可以用一种更简单的方式，把这个类交给Spring去管理，就是在该类上加一个@Component注解， @Component注解有一个value的属性，就是相当于标签中的id属性，可以不写，不写就默认是类名首字母小写（userService）

        除此之外我们要去application.xml文件中加一个约束，

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

        如果不会加的直接把下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"
       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">

        测试方法和以前一样

@Test
public void run2(){
    ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");

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

    userService.hello();
}

5.2 常用的注解

bean管理类常用的4个注解（作用相同，推荐使用在不同分层上）

​@Component 普通的类

​@Controller 表现层

​@Service 业务层

​@Repository 持久层

依赖注入常用的注解

​@Value 用于注入普通类型（String，int，double等类型）

​@Autowired 默认按类型进行自动装配（引用类型）

​@Qualifier 和@Autowired一起使用，强制使用名称注入

​@Resource Java提供的注解，也被支持。使用name属性，按名称注入

对象生命周期（作用范围）注解

​ @Scope 生命周期注解，取值singleton（默认值，单实例）和prototype（多例）

初始化方法和销毁方法注解（了解）

​ @PostConstruct 相当于init-method

​ @PreDestroy 相当于destroy-method

5.3 通过注解的方式DI注入

创建一个Car的类

@Component("car")
public class Car {

    @Value("小米su7")
    private String name;

    @Value("300000")
    private Double price;

    @Autowired

    private Student owner;

    public Car() {
    }

    public Car(String name, Double price, Student owner) {
        this.name = name;
        this.price = price;
        this.owner = owner;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public Student getOwner() {
        return owner;
    }

    public void setOwner(Student owner) {
        this.owner = owner;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", owner='" + owner + '\'' +
                '}';
    }
}

        再写一个Student的类

@Component("student")
public class Student {

    @Value("小明")
    private String name;

    @Value("24")
    private Integer age;

    @Value("大数据")
    private String classname;

    public Student() {
    }

    public Student(String name, Integer age, String classname) {
        this.name = name;
        this.age = age;
        this.classname = classname;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getClassname() {
        return classname;
    }

    public void setClassname(String classname) {
        this.classname = classname;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", classname='" + classname + '\'' +
                '}';
    }
}

注意：要把配置文件中的application.xml中的扫描包改成这两个类所在的包

然后编写测试方法

@Test
public void run3(){

    ApplicationContext ac=new ClassPathXmlApplicationContext("application.xml");

    Car car = (Car) ac.getBean("car");

    System.out.println(car);
}

剩下的哪些注解就不一一演示了，有兴趣的自己探索一下吧

对了，这个注解的方式注入值的时候，不用自己生成set方法，因为他直接在你要加的属性的加的注释，所以就Spring是框架直接给你的属性注入的值，如果需要set方法注入，直接在set方法上用@Value的注解，就是使用set方法注入

5.4 通过纯注解的方式开发

        顾名思义，就是就是只用注解不写配置文件的方式来进行开发。

        但是需要写一个配置类，就是用来代替配置文件的东西。

//声明当前的类是配置类
@Configuration
//指定扫描的包的位置
@ComponentScan("com.qcby")
public class SpringConfig {
}

        写一个实体类

@Component
public class Order {

    @Value("保定")
    private String address;

    public Order() {
    }

    public Order(String address) {
        this.address = address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

测试类

@Test
public void run4(){
    ApplicationContext ac =new AnnotationConfigApplicationContext(SpringConfig.class);
    Order order = (Order) ac.getBean("order");
    System.out.println(order);
}

常用的注解总结

@Configuration 声明是配置类

@ComponentScan 扫描具体包结构的

@Import注解 Spring的配置文件可以分成多个配置的，编写多个配置类。用于导入其他配置类

@Bean注解 只能写在方法上，表明使用此方法创建一个对象，对象创建完成保存到IOC容器中

@Bean和@Component的区别：

@Component是加在类上的

@Bean是加在方法上的

本质上来说都是告诉Spring框架要创建一个类

举个栗子

@Bean
public void createDataSource(){
    DruidDataSource dataSource=new DruidDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql:///spring_db");
    dataSource.setUsername("root");
    dataSource.setPassword("password");
}

6.Spring整合junit的测试

我们在上面写测试方法的时候就每次都要读取配置文件或者配置类创建一个工厂对象，然后去获取bean对象，这就造成了一个代码冗余的问题。

为了解决这个问题，Spring提供了整合Junit单元测试的技术，可以简化测试开发。下面开始学习该技术。

必须先有Junit单元测试的环境，也就是说已经导入Junit单元测试的jar包。咱们已经导入过了。使用的是4.12版本

再导入spring-test的坐标依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>\
    <version>5.0.2.RELEASE</version>
    <scope>test</scope>
</dependency>

        然后我们去model包下写一个User的类

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

        创建一个application01.xml的配置文件，将写好的User类交给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: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">

   <bean id="user" class="com.qcby.model.User"/>

</beans>

        这时候我们自己写测试的话按照以上的方式就是这么写

public class Test {
    @Test
    public void run1(){
        ApplicationContext ac= new ClassPathXmlApplicationContext("application01.xml");
        User user=(User) ac.getBean("user");
        user.sayHello();

    }
}

        然后我们导入依赖的时候不是导入了整合junit的测试了吗，然后我们就可以用Spring整合的junit去测试一下。

/**
 * @RunWith(SpringJUnit4ClassRunner.class)声明该类是是一个测试单元
 * @ContextConfiguration(value = "classpath:application01.xml")指定Spring配置文件的位置,加载该配置文件
 */
@RunWith(value = SpringJUnit4ClassRunner.class)
@ContextConfiguration(value ="classpath:application01.xml")
public class Test01 {

    @Autowired
    public User user;

    @Test
    public void run() {
        user.sayHello();
    }
}

        主要是@RunWith(value = SpringJUnit4ClassRunner.class)声明是一个测试单元

        @ContextConfiguration(value ="classpath:application01.xml")声明要加载的配置文件或者配置类

        

补充一点

@Autowired是按照类型注入，因为是单例的所以就可以直接按类型找到并注入，可以节省内存速度

背着黄油面包的猫
关注
  • 22
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring5 框架 ---- IOC容器 ---- 代码
09-10
Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- ...
Spring框架-IoC容器
11-13
Spring-IoC容器
详解Spring框架---IOC装配Bean
08-31
IOC（Inversion of Control，控制反转）是Spring框架的核心理念之一，它将Bean的创建、管理和依赖关系从应用程序中分离出来，使得应用程序更加灵活、可维护和可扩展。 在Spring框架中，Bean是应用程序的核心组件，...
Spring核心-IOC（3）
03-12
在Spring框架中，IOC（Inversion of Control，控制反转）是其核心概念之一，它改变了传统应用程序中的对象创建和管理方式。本篇文章将深入探讨Spring的IOC容器以及它如何通过自动装配（Autowired）来实现依赖注入，...
Java-Spring-SpringIoC容器-SpringIoC的学习
10-11
在Java Spring框架中，Spring IoC（Inversion of Control，控制反转）是核心特性之一，它使得应用程序的...在实际开发中，还可以结合@Autowired注解、Profile特性、Java配置类等方式，进一步优化和扩展IoC容器的功能。
dubbo和springcloud有什么异同？
yszbrzdd的博客
08-15 381
Dubbo主要关注于高效的 RPC 调用和服务治理。提供了一个综合的微服务解决方案，涵盖了从服务注册到配置管理的广泛功能。它们可以根据具体需求和现有技术栈选择使用，也可以结合使用，例如在 Spring Cloud 环境中集成 Dubbo 作为 RPC 框架。
spring揭秘06-Autowired自动绑定依赖及组件自动扫描
最新发布
PacosonSWJTU的博客
08-16 460
Resource注解可以替代 @Autowired 与 @Qualilfier这2个注解结合的功能，即根据beanName到spring容器中查找匹配的bean，并注入依赖关系到当前bean（如Jsr250AnnotationBookAppService）；
spring中使用到的设计模式有哪些
weixin_47503016的博客
08-12 320
spring 使用到的设计模式
SpringBoot
qq_74812898的博客
08-12 597
SpringBoot
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 329
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 558
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
Mybatis_springboot与mybatis-plus
m0_74002833的博客
08-13 1053
MyBatis 是一个流行的持久层框架，可以与 Spring Boot 无缝集成。下面是如何在 Spring Boot 项目中使用 MyBatis 的基本步骤。
SpringBoot-04--整合登录注册动态验证码
ngczx的博客
08-16 477
SpringBoot+Vue3+Redis+工具实现动态的登录验证码，用到了Base64编码
Spring 事务配置类，完成数据库的转账
or77iu_N的博客
08-15 420
【代码】Spring 事务配置类，完成数据库的转账。
SpringBoot整合MyBatis-Plus完整详细版（提供Gitee源码）
黄团团的个人博客
08-13 113
本篇文章完整详细介绍了SpringBoot整合MyBatis-Plus的完整过程，这边我的SpringBoot版本是2.4版本、JDK1.8和Maven3.8.1版本，跟着文章一步步走就可以了，MyBatis-Plus整合非常方便，也是现在企业开发中经常会用的一个持久层框架。
SpringBoot优雅开发REST API最佳实践
糖拌西红柿
08-13 1477
SpringBoot接口版本控制、接口动态版本号、参数校验、@validated注解、Controller统一异常拦截、@RestControllerAdvice注解、参数处理、Swagger使用方法、接口文档
spring @Transactional 是怎么实现事务的
qq_43197840的博客
08-16 249
Spring的注解通过Spring的事务管理机制实现事务控制。这个机制主要依赖于Spring的AOP（面向切面编程）和事务管理器（Transaction Manager）。下面是。
SpringBoot Profile多环境配置及配置优先级
qq_27361945的博客
08-16 176
但是我们发现一个问题，就是每次切换环境还需要去配置里指定，然后通过修改dev为test或prod来切换项目环境 , 这样做的话每次切换环境都要重新改一下配置 , 而且如果不小心把本地改动提交到中央仓库了 , 可能会影响到其他同事拉取代码，maven中提供了一个profile配置项,可以在打包时动态的指定环境配置.结合idea使用 , 我们可以实现不动任何代码来随意的切换我们的工作环境。-- 之前写的@env@就是通过这里的配置切换环境 -->-- 开发环境 -->-- 生产环境 -->
初识Spring
2401_82742105的博客
08-12 368
Part1 Spring历史由来 一、企业级应用 随着计算机以及互联网的发展，社会对于软件系统的需求越来越多，也越来越复杂，所以提出了企业级应用。 企业级应用指的是 大规模、性能和安全要求高、业务复杂、灵活多变 的大型 WEB 应用程序。 ●大规模 用户量和 IP/PV访问量大、海量数据、功能模块多代码量大。 ●业务复杂 涉及金融、期货、电信等特殊领域的业务逻辑复杂，对系统架构提出新要求。 ●性能和安全要求高 响应毫秒数和安全级别均有很高的要求 ●灵活多变 经常性的业务变更，也对开发效率以及项目部署等工
Spring 3.0 MVC + 注解全面教程：从IoC到DI与AOP
本篇文档是关于Spring 3.0版本的全面学习指南，涵盖了Spring框架的核心概念、依赖注入(DI)、控制反转(IoC)、面向切面编程(AOP)以及资源管理和表达式语言等方面。作者以"跟我学Spring3"系列的形式呈现，旨在提供一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值