金山老师的笔记

Appearance

2. Spring入门程序 ​

Spring中的Bean：使用容器管理的对象统一称之为Bean

2.1. 类与类的依赖关系 ​

IUserDao，dao层的接口类

List selectUsers();

UserDaoImpl，dao层的实现类

List selectUsers(){

}

IUserService 定义一个方法

List queryUsers();

UserServiceImpl 实现类,依赖（属性）IUserDao

List queryUsers(){

调用Dao层的方法

}

2.2. 创建工程 ​

2.2.1. Spring的工程(父工程) ​

img

2.2.2. Spring-01-hello(子项目) ​

img

2.2.3. 上述四个类实现（代码创建完） ​

2.2.3.1. IUserDao 接口 ​

java
/**
 * 项目    ： spring-java1
 * 创建时间 ：2020/3/19  16:18 19
 * author  ：张金山
 * site    :   https://jshand.gitee.io
 * 描述     : dao层接口
 */
public interface IUserDao {
    List selectUser();
}

2.2.3.2. UserDaoImpl 实现类 ​

java
import java.util.List;

/**
 * 项目    ： spring-java1
 * 创建时间 ：2020/3/19  16:18 19
 * author  ：张金山
 * site    :   https://jshand.gitee.io
 * 描述     : dao层的实现类
 */
public class UserDaoImpl implements IUserDao {
    @Override
    public List selectUser() {
        System.out.println("执行dao层的方法......");
        return null;
    }
}

2.2.3.3. IUserService 接口 ​

java
import java.util.List;

/**
 * 项目    ： spring-java1
 * 创建时间 ：2020/3/19  16:19 19
 * author  ：张金山
 * site    :   https://jshand.gitee.io
 * 描述     : Service层接口
 */
public interface IUserService {

    List queryUser();
}

2.2.3.4. UserServiceImpl 实现类 ​

java
import com.neuedu.dao.IUserDao;

import java.util.List;

/**
 * 项目    ： spring-java1
 * 创建时间 ：2020/3/19  16:20 19
 * author  ：张金山
 * site    :   https://jshand.gitee.io
 * 描述     : service层的实现类
 */
public class UserServiceImpl implements  IUserService {

    IUserDao userDao ;


public UserServiceImpl(IUserDao userDao) {
    this.userDao = userDao;
}

 


    @Override
    public List queryUser() {
        userDao.selectUser();
        return null;
    }
}

2.3. 依赖Spring的类库 ​

xml
<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.2.4.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.2.4.RELEASE</version>
</dependency>


<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.4.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>5.2.4.RELEASE</version>
</dependency>

2.4. 由Spirng维护依赖关系 ​

2.4.1. 使用java代码的形式维护类的创建和依赖 ​

2.4.1.1. AppConfig ​

java
@Configuration //让当前类作为配置类存在（管理bean对象）
public class AppConfig {

    //管理Dao的创建
    @Bean
    public IUserDao getDao(){
       return  new UserDaoImpl();
    }

    //管理service的创建
    @Bean
    public IUserService getService(){
        return  new UserServiceImpl();
    }
}

2.4.1.2. 单元测试 ​

java
/**
 * Unit test for simple App.
 */
public class AppTest {
    
    @Test
    public void test1(){
        //1 获取工厂
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        //由工厂创建Service、Dao
        //测试从工厂获取Dao
        IUserDao userDao = context.getBean(IUserDao.class);
        //userDao.selectUser();//从工厂中获取到 dao对象

        //测试从工厂获取service
        IUserService userService = context.getBean(IUserService.class);
        userService.queryUser();//从工厂中获取到 dao对象
    }
}

2.4.2. 使用xml的形式维护类的创建和依赖 ​

2.4.2.1. 准备xml配置Service和Dao的申明依赖 ​

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 使用bean标签声明bean对象

        id : 在容器中的名字，不能重复
        class : 对象的类型
    -->
    <bean id="userDao" class="com.neuedu.dao.UserDaoImpl">
    </bean>

    <bean id="userService" class="com.neuedu.service.UserServiceImpl">
        <!-- service 依赖（需要）userDao，使用构造器的方法传递进入
            constructor-arg
                name属性 构造器中的参数名
                value：给参数赋值（常量）
                ref: 引用容器中的 其他bean的id
        -->
        <constructor-arg name="userDao" ref="userDao" ></constructor-arg>
    </bean>
    
</beans>

2.4.2.2. 单元测试 ​

java
  /**
     * 使用xml的方式管理bean的创建
     */
    @Test
    public void test2(){
        //1 获取工厂context (容器)
        String configLocation = "spring-beans.xml";
        ApplicationContext context = new ClassPathXmlApplicationContext(configLocation);

        //由工厂创建Service、Dao
        //测试从工厂获取Dao
//        IUserDao userDao = context.getBean(IUserDao.class);
//        userDao.selectUser();//从工厂中获取到 dao对象

        //测试从工厂获取service
        IUserService userService = context.getBean(IUserService.class);
        userService.queryUser();//从工厂中获取到 service对象

    }

2.4.3. 使用注解扫描的形式维护类的创建和依赖 ​

img

2.4.3.1. 在需要使用容器管理的类上声明注解 ​

@Component代表需要让容器给我创建对象，spring额外提供了3个同样功能的注解

@Service、@Repository、@Controller作用一样，只是从语义上进行区分。

  • dao
java
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * 项目    ： spring-java1
 * 创建时间 ：2020/3/19  16:18 19
 * author  ：张金山
 * site    :   https://jshand.gitee.io
 * 描述     : dao层的实现类
 */
@Component
public class UserDaoImpl implements IUserDao {
    @Override
    public List selectUser() {
        System.out.println("执行dao层的方法......");
        return null;
    }
}
  • Service
java
import com.neuedu.dao.IUserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * 项目    ： spring-java1
 * 创建时间 ：2020/3/19  16:20 19
 * author  ：张金山
 * site    :   https://jshand.gitee.io
 * 描述     : service层的实现类
 */

@Component
public class UserServiceImpl implements  IUserService {

    @Autowired // 自动的将容器中IUserDao的类注入到 userDao属性
    IUserDao userDao ;

    //声明无参的构造器
    public UserServiceImpl(){
    }


    public UserServiceImpl(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public List queryUser() {
        System.out.println("执行serive层的方法");
        userDao.selectUser();
        return null;
    }
}

2.4.3.2. 在xml中声明需要扫描的包 ​

创建spring-beans-annotation.xml配置文件

使用 <context:component-scan base-package="com.neuedu"/>进行扫描

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

   <!--指定包进行扫描 -->
  <context:component-scan base-package="com.neuedu.dao,com.neuedu.service"/>
</beans>

2.4.3.3. 单元测试 ​

java
/**
     * 使用注解扫描的形式的方式管理bean的创建
     */
    @Test
    public void test3(){
        //1 获取工厂context (容器)
        String configLocation = "spring-beans-annotation.xml";
        ApplicationContext context = new ClassPathXmlApplicationContext(configLocation);

        //由工厂创建Service、Dao
        //测试从工厂获取Dao
//        IUserDao userDao = context.getBean(IUserDao.class);
//        userDao.selectUser();//从工厂中获取到 dao对象

        //测试从工厂获取service
        IUserService userService = context.getBean(IUserService.class);
        userService.queryUser();//从工厂中获取到 service对象

    }

2.5. 整合Junit单元测试 ​

2.5.1. 1修改junit的库变为4.12+ ​

xml
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

2.5.2. 1添加Spring的test模块 ​

xml
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.4.RELEASE</version>
</dependency>

2.5.2.1. 单元测试 ​

java
/**
 * 项目    ： spring-java1
 * 创建时间 ：2020/3/20  10:06 20
 * author  ：张金山
 * site    :   https://jshand.gitee.io
 * 描述     : junit集成Spring的测试库
 */
@RunWith(SpringJUnit4ClassRunner.class) //对junit的扩展
@ContextConfiguration(locations="classpath:spring-beans-annotation.xml")
public class SpringTest {


    @Autowired
    IUserService userService;

    @Test
    public void test(){
        userService.queryUser();
    }
}

注意，以后的测试SpringJunit4ClassRunner ,但是底层还是ApplicationContext。

Released under the MIT License.

Copyright © 2024-present 金山老师