spring_练习题一

最新推荐文章于 2023-04-06 20:34:07 发布

番茄西红柿v_v

最新推荐文章于 2023-04-06 20:34:07 发布

阅读量1k

点赞数 1

文章标签： spring java 后端

本文链接：https://blog.csdn.net/weixin_41438423/article/details/125057840

版权

1 简答题

1.1 简答题一

请简述BeanFactory和ApplicationContext有什么区别?

答: 
1.BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当作Spring的容器。其中ApplicationContext是BeanFactory的子接口。
2.BeanFactory采用的是延迟加载形式来注入Bean,即只有在使用到某个Bean时才会去创建该Bean对象，ApplicationContext是在容器启动时，一次性创建了所有的Bean。

1.2 简答题二

请简述Spring中容器创建与Bean对象获取的几种常见方式有哪些?

答：
创建容器的方式:
1.使用ClassPathXmlApplicationContext,此种方式是从类路径下查找配置文件
2.使用FileSystemXmlApplicationContext，此种方式是从系统的文件系统下查找配置文件
获取Bean的方式:
1.getBean("beanId"),该方式是根据传入的beanId来获取bean对象，需要进行类型强制转换
2.getBean("beanId",类.class),该方式可以不用进行类型转换，但是需要传递两个参数
3.getBean(类.class),该方式是根据类型来获取bean对象，但是需要保证容器中该类的对象只能有一个

1.3 简答题三

请简述Spring中IOC与DI的常见注解有哪些?

答:
1.@ComponentScan：设置spring配置类扫描路径，用于加载使用注解格式定义的bean
2.@Component: 设置该类为spring管理的bean
3.由@Component衍生出其他三个注解，@Controller,@Service,@Repository
4.@Configuration:编写在类上，标识该类为一个配置类
5.@Bean:编写在方法上，会将方法的返回值制作成Spring容器中的一个bean对象
6.@Autowired:为引用类型属性设置值
7.@Qualifier:为引用类型属性指定注入的beanId
8.@Value:为基本数据类型或或字符串类型属性设置值
9.@PropertySource：加载properties文件中的属性值
10.@Import:在当前类中引入其他的配置类
11.@Scope:该注解用来指定bean的作用范围
12.@PostConstructor:写在方法上，设置该方法为初始化方法
13.@PreDestroy:写在方法上，设置该方法为销毁方法

1.4简答题四

请简述Spring整合Junit的实现步骤是什么?

答:
1.引入对应的依赖
2.创建测试类
3.类上添加注解
	@RunWith(SpringJUnit4ClassRunner.class),用来设置Junit运行器
	@ContextConfiguration,用来加载Spring的核心配置
		class：加载核心配置类
		locations:加载核心配置文件
4.在测试类中注入需要测试的对象，然后调用方法进行测试

1.5 简答题五

请简述Spring整合Mybatis的实现步骤是什么?

答:
Spring整合Mybatis，就是将Mybatis的相关资源交给Spring来管理。
Mybatis主要是对数据库表的增删改查，所以
1.需要先有一个数据库及表
2.需要操作表，就需要连接数据库，连接数据库就需要配置数据源，此处采用的是DruidDataSource
3.连接池需要配置数据库连接四要素，分布是 驱动、url地址、用户名、密码，将这些信息配置到Jdbc.properties，并且Spring加载环境的时候需要使用@PropertySource加载该配置文件
4.Mybatis操作数据库的核心对象为SqlSession,Mybatis整合Spring的包中有提供SqlSessionFactoryBean用来创建SqlSession,需要进行配置，Spring容器中要创建所有的Mapper接口对象，则需要配置MapperScannerConfigurer用来扫描Mapper接口所在的包，所以将这两个对象配置到MybatisConfig配置类中
5.需要将Spring的配置和Mybatis的配置都需要引入到Spring的环境，所以需要添加SpringConfig配置类
6.针对具体的业务开始编写对应的Service接口、Service实现类以及Mapper接口
7.编写测试类进行测试

1.6 简答题六

请简述BeanFactory和FactoryBean的区别是什么?

答:
1.BeanFactory是一个工厂接口，重点落在Factory上,是Spring中所有工厂类的父接口，用于创建和管理容器中的bean对象
2.FactoryBean是一个Bean接口，重点落在Bean上，就是一个bean，主要用来构建比较复杂的bean对象，FactoryBean接口中有三个方法分别是getObject(返回bean对象放入容器)、getObjectType(返回bean对象的具体类型)、isSingleton(返回bean是否为单例)

2 编程题

2.1 编程题目一

训练目标：熟练掌握Spring整合Mybatis的实现步骤及相关配置类的配置

需求描述：请在给定的基础环境中将Spring整合Mybatis所需要的内容补充完整。

1、在JdbcConfig配置类中读取jdbc。properties文件中数据库四要素，用来构建连接池对象

2、在MybatisConfig配置类中构建SqlSessionFactoryBean和MapperScannerConfigurer

3、在SpringConfig配置类中添加Spring相关的配置

素材说明：

1、素材中的spring_task_03是基础的开发环境，需将其导入到IDEA中并按照提示将配置补充完整

2、项目所需依赖均匀完成导入

实现提示：

1、SpringConfig配置类中需要设置service的包扫描、加载properties配置文件、引入其他的配置类

2、jdbc.properties配置文件中需要将数据库连接信息改成自己的数据库连接信息

实现思路：

1、将素材中spring_task_03加载到IDEA中并修改Maven与JDK的配置

2、分别打开JdbcConfig、MybatisConfig以及SpringConfig类进行配置

代码实现：

1、打开JdbcConfig配置类

//TODO:构建数据库连接池对象DataSource
public class JdbcConfig {
    //1.驱动
    @Value("${jdbc.driver}")
    private String driver;
    //2.url地址
    @Value("${jdbc.url}")
    private String url;
    //3.用户名
    @Value("${jdbc.username}")
    private String userName;
    //4.用户密码
    @Value("${jdbc.password}")
    private String password;

    @Bean
    //构建DataSource对象
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

2、打开MybatisConfig配置类进行配置

public class MybatisConfig {

    //TODO:构建SqlSessionFactoryBean对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setTypeAliasesPackage("com.itheima.domain");
        return sqlSessionFactoryBean;
    }
    //TODO:构建MapperScannerConfigurer对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("com.itheima.mapper");
        return mapperScannerConfigurer;
    }
}

3、打开SpringConfig配置类进行配置

@Configuration
@ComponentScan("com.itheima.service")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {

}

2.2 编程题目二

训练目标：能够熟练的在Spring整合Mybatis环境中实现对应功能的开发并使用Spring整合Junit进行测试。

需求描述：临近过年，公司需要统计员工过年的行程，现在需要在题目一的环境中对行程表进行功能维护，项目中所使用的实体类、Service接口、Service实现类、Mapper接口以及单元测试类需要自行创建完成。

1、查询行程表中所有的数据

2、添加用户过年的形成数据

3、根据ID查询用户的行程数据

4、根据ID修改用户的行程数据

5、根据ID删除用户的行程数据

6、编写测试类,将测试结果打印至控制台。

在这里插入图片描述

素材说明：

1、将素材中trip.sql导入到自己本地数据库spring_db中

2、请在题目一搭建好的开发环境spring_task_03`上进行代码编写

实现提示：

1、将Service和Dao层都需要交给Spring管理，创建包结构的时候需要参考自己的配置类中的配置

实现思路：

1、根据数据库表创建实体类

2、创建Mapper接口，按照要求完成数据库表的增删改查

3、创建Service接口和实现类，根据需求完成业务方法的编写

4、编写测试类，使用Spring整合Junit对业务层Service进行测试

代码实现：

1、根据数据库表创建实体类

public class Trip implements Serializable {
    private Long id; //主键ID
    private String username; //用户名称
    private Integer gender; //0:女 1:男
    private String idcard; //用户身份证
    private String fromAddress; //出发地
    private String toAddress;//到达地
    private Date startTime;//出发时间
    //setter...getter...toString...略
}

2、编写对应的Mapper接口，并实现增删改查方法

public interface TripMapper {
    /**
     * 查询所有
     * @return
     */
    @Select("select id,username,gender,idcard,from_address fromAddress,to_address toAddress,start_time startTime from tb_trip")
    public List<Trip> queryAll();

    /**
     * 新增
     * @param trip
     * @return
     */
    @Insert("insert into tb_trip values(null,#{username},#{gender},#{idcard},#{fromAddress},#{toAddress},#{startTime})")
    public int save(Trip trip);

    /**
     * 根据ID查询
     * @param id
     * @return
     */
    @Select("select id,username,gender,idcard,from_address fromAddress,to_address toAddress,start_time startTime from tb_trip where id = #{id}")
    public Trip queryById(Long id);

    /**
     * 修改
     * @param trip
     * @return
     */
    @Update("update tb_trip set username =#{username},gender=#{gender},idcard=#{idcard},from_address=#{fromAddress},to_address=#{toAddress},start_time = #{startTime} where id =#{id}")
    public int update(Trip trip);

    /**
     * 根据ID删除
     * @param id
     * @return
     */
    @Delete("delete from tb_trip where id = #{id}")
    public int deleteById(Long id);
}

3、编写Service接口

public interface TripService {
    /**
     * 查询所有
     * @return
     */
    public List<Trip> findAll();

    /**
     * 新增
     * @param trip
     * @return
     */
    public int saveTrip(Trip trip);

    /**
     * 根据ID查询
     * @param id
     * @return
     */
    public Trip findById(Long id);

    /**
     * 修改
     * @param trip
     * @return
     */
    public int updateTrip(Trip trip);

    /**
     * 根据ID删除
     * @param id
     * @return
     */
    public int deleteById(Long id);
}

4、编写Service实现类

@Service
public class TripServiceImpl implements TripService {

    @Autowired
    private TripMapper tripMapper;

    public List<Trip> findAll() {
        return tripMapper.queryAll();
    }

    public int saveTrip(Trip trip) {
        return tripMapper.save(trip);
    }

    public Trip findById(Long id) {
        return tripMapper.queryById(id);
    }

    public int updateTrip(Trip trip) {
        return tripMapper.update(trip);
    }

    public int deleteById(Long id) {
        return tripMapper.deleteById(id);
    }
}

5、编写测试类，进行单元测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class TripServiceTest {

    @Autowired
    private TripService tripService;

    @Test
    public void testFindAll(){
        List<Trip> list = tripService.findAll();
        for (Trip trip : list) {
            System.out.println(trip);
        }
    }

    @Test
    public void testAdd(){
        Trip trip = new Trip();
        trip.setUsername("TOM");
        trip.setGender(1);
        trip.setIdcard("61011220000202X");
        trip.setFromAddress("西安");
        trip.setToAddress("北京");
        trip.setStartTime(new Date());
        int rst = tripService.saveTrip(trip);
        System.out.println(rst);
    }

    @Test
    public void testFindById(){
        Trip trip = tripService.findById(16L);
        System.out.println(trip);
    }

    @Test
    public void testUpdate(){
        Trip trip = tripService.findById(16L);
        trip.setFromAddress("深圳");
        trip.setToAddress("西安");
        int rst = tripService.updateTrip(trip);
        System.out.println(rst);
    }

    @Test
    public void testDeleteById(){
        int rst = tripService.deleteById(16L);
        System.out.println(rst);
    }
}

2.3 编程题目三

训练目标：练习表的设计与多表关联查询

需求描述：当把用户的行程功能开发完后，突然发现在用户的行程表中存在与用户表相同的内容，也就是说出现了冗余数据，这样会提升后期代码的维护成本，现在要求你行程表进行重新设计来解决上述问题。

在这里插入图片描述

1、将tb_trip表重新设计，为了不影响原有功能，将表命名为tb_trip_new

2、编写SQL语句将旧数据导入到新表中

3、根据表构建对应的实体类、Dao与Service

4、在重新设计的表的基础上完成员工旅程列表信息查询，要求查询的过程只能与数据库交互一次。

在这里插入图片描述

素材说明：

1、将素材中的user.sql导入到数据库spring_db中

2、代码直接编写在spring_task_03项目中

实现提示：

1、表重新设计后，tb_user和tb_trip就会产生关联关系，所以再次查询数据的时候，就需要用到关联查询或子查询

2、在导入数据的时候，需要先将结果查询出来然后再插入到新表中

2、为了接收从数据库表中查询的数据，可以使用Map或者重新构建一个新的实体类

实现思路：

1、重新创建数据库表，将用户相关信息使用用户ID替换

2、编写Sql语句导入数据到新表中

3、根据表创建实体类

4、创建对应的Mapper接口、Service接口与Service实现类

5、完成员工旅程列表数据查询，从Service调用Mapper,在Mapper中编写对应的SQL语句

6、编写单元测试类进行测试

代码实现：

1、构建表 tb_trip_new,需要将tb_trip表中的冗余数据，使用用户ID来替换。

CREATE TABLE `tb_trip_new` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `user_id` BIGINT(20) DEFAULT NULL COMMENT '员工ID',
  `from_address` VARCHAR(255) DEFAULT NULL COMMENT '出发地',
  `to_address` VARCHAR(255) DEFAULT NULL COMMENT '到达地',
  `start_time` DATETIME DEFAULT NULL COMMENT '出发时间',
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=32 DEFAULT CHARSET=utf8

2、编写Sql语句完成数据的导入，用户的身份证号是一致的，可以使用身份证号进行关联查询

INSERT INTO tb_trip_new (user_id,from_address,to_address,start_time) SELECT u.id,p.from_address,p.to_address,p.start_time FROM tb_user u LEFT JOIN tb_trip p ON u.idcard = p.idcard

3、编写实体类

public class TripNew implements Serializable{

    private Long id; //主键ID
    private Long userId;//用户ID
    private String fromAddress; //出发地
    private String toAddress;//到达地
    private Date startTime;//出发时间
    
     //setter...getter...toString...略
}

4、为了接收查询的结果数据，编写一个新的实体类

public class TripNewVo implements Serializable{
    private Long id; //主键ID
    private String username; //用户名称
    private Integer gender; //0:女 1:男
    private String idcard; //用户身份证
    private String fromAddress; //出发地
    private String toAddress;//到达地
    private Date startTime;//出发时间
     //setter...getter...toString...略
}

5、编写TripNewService接口

public interface TripNewService {
    /**
     * 查询所有的旅程数据
     * @return
     */
    public List<TripNewVo> findAll();
}

6、编写TripNewServiceImpl实现类

@Service
public class TripNewServiceImpl implements TripNewService {
    @Autowired
    private TripNewMapper tripNewMapper;
    
    public List<TripNewVo> findAll() {
        return tripNewMapper.queryAll();
    }
}

7、编写TripNewMapper接口

public interface TripNewMapper {
    @Select("SELECT tn.id,tn.from_address fromAddress,tn.to_address toAddress, tn.start_time startTime,u.username,u.idcard,u.gender FROM tb_trip_new tn LEFT JOIN tb_user u ON tn.user_id = u.id")
    public List<TripNewVo> queryAll();
}

8、编写测试类进行测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class TripNewServiceTest {

    @Autowired
    private TripNewService tripNewService;

    @Test
    public void testFindAll(){
        List<TripNewVo> list = tripNewService.findAll();
        for (TripNewVo tripVo : list) {
            System.out.println(tripVo);
        }
    }

}

ime,u.username,u.idcard,u.gender FROM tb_trip_new tn LEFT JOIN tb_user u ON tn.user_id = u.id")
public List queryAll();
}


8、编写测试类进行测试

```java
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class TripNewServiceTest {

    @Autowired
    private TripNewService tripNewService;

    @Test
    public void testFindAll(){
        List<TripNewVo> list = tripNewService.findAll();
        for (TripNewVo tripVo : list) {
            System.out.println(tripVo);
        }
    }

}

番茄西红柿v_v

关注

1
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
spring_练习题一

1 简答题1.1 简答题一请简述BeanFactory和ApplicationContext有什么区别?答: 1.BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当作Spring的容器。其中ApplicationContext是BeanFactory的子接口。2.BeanFactory采用的是延迟加载形式来注入Bean,即只有在使用到某个Bean时才会去创建该Bean对象，ApplicationContext是在容器启动时，一次性创建了所有的Bean
复制链接

扫一扫