Spring框架(一)：基础

目录

1、Spring

2、Spring组成

3、Spring Boot

4、Spring配置

4.1、别名

4.2、bean的配置

4.3、import

5、依赖注入

5.1、构造函数注入

5.2、set方法注入（***）

5.3、p/c空间注入 

6、Bean的作用域

1、单例模式(Spring默认)

2、原型模式

7、Bean的自动装配

7.1、自动装配是Spring满足bean依赖的一种方式

7.2、ByName自动装配

7.3、byType自动装配

7.4、注解自动装配

 8、使用注解开发

1、bean

2、属性如何注入

3、衍生注解  

 4、自动装配

 5、作用域

6、小结

 9、使用Java的方式配置Spring

10、代理模式

​ 10.1、静态代理

AOP

10.2、动态代理

 11、AOP

1、AOP

2、AOP在spring中作用

3、使用Spring实现AOP 

12、整合mybatis

12.1、mybatis步骤

13、Mybatis-Spring整合 

 13.1、入门

 14、SqlSessionDaoSupport 

15、声明式事务

---

1、Spring

优点

• Spring是一个开源的免费框架（容器）
• Spring是一个轻量级的、非入侵式的框架
• IOC控制反转、AOP面向切面编程
• 支持事务的处理、对框架整合

Spring就是一个轻量级的控制反转和面向切面变成的框架。

2、Spring组成

1. Spring Core
框架的最基础部分，提供 IoC 容器，对 bean 进行管理。

2.Spring Context
基于 bean，提供上下文信息，扩展出JNDI、EJB、电子邮件、国际化、校验和调度等功能。

3．Spring DAO
提供了JDBC的抽象层，它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码，还提供了声明性事务管理方法。

4.Spring ORM
提供了常用的“对象/关系”映射APIs的集成层。 其中包括JPA、JDO、Hibernate、MyBatis 等。

5.Spring AOP
提供了符合AOP Alliance规范的面向方面的编程实现。

6.Spring Web
提供了基础的 Web 开发的上下文信息，可与其他 web 进行集成。

7.Spring Web MVC
提供了 Web 应用的 Model-View-Controller 全功能实现。

3、Spring Boot

Sping Boot

• 一个快速开发的脚手架
• 基于Spring Boot可以快速的开发耽搁微服务
• 约定大于配置

Spring Cloud

• Spring Cloud基于SpringBoot实现

4、Spring配置

4.1、别名

4.2、bean的配置

4.3、import

一般用于团队开发使用，可以将多个配置文件导入合并为一个。

xml的正常名称：applicationContect.xml

5、依赖注入

5.1、构造函数注入

5.2、set方法注入（***）

依赖：bean对象的创建依赖容器

注入：bean对象所有属性由容器注入

        普通注入：value

        bean注入：ref

        空值注入：

        数组：

        property注入：

        list:

        set:

        map:

5.3、p/c空间注入 

我们可以使用p空间和c空间注入

注意：p和c空间不能直接使用，需要导入xml约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

6、Bean的作用域

bean的作用范围调整

bean对象默认是单例

bean标签的scope属性： 作用：用于指定bean的取值范围 取值： 常用：单例和多例 singleton:单例（默认）

prototype：多例

request：作用于web应用的请求范围

session：作用于web应用的会话范围

global-session:：作用于集群环境的会话范围（全局会话范围），当不是集群时，他就是session

1、单例模式(Spring默认)

容器中一个类只有一个对象

  
 
  
2、原型模式
 
  
每次从容器中get()时，都会产生一个新对象。
 
  
 
   
 
  
3、其余request、session、application都在web中使用
 
  
7、Bean的自动装配
 
  
7.1、自动装配是Spring满足bean依赖的一种方式
 
  
Spring会在上下文中自动寻找，并自动给bean装配属性
 
  
Spring三种装配方式
 
  
 
   
在xml中显示配置
 
   
在java中显示配置
 
   
隐式的自动装配bean（****）
 
  
 
  
7.2、ByName自动装配
 
  
之前
 
  
 
   

     
     
     



 
  
 
  
 
   
需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法后面的值一致。
 
   
会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid。
 
  
 
  
setDog----dog----id="dog"。setCat ----cat------id="cat" 。
 
  
 
   

    


 
  
 
  
7.3、byType自动装配
 
  
 
   
需要保证所有bean的class 唯一，并且这个bean需要和自动注入的属性的类型一致。
 
   
会自动在容器上下文中查找，和自己对象属性类型相同的bean，必须保证容器中类型全局唯一。
 
  
 
  
 
   

    


 
  
 
  
7.4、注解自动装配
 
  
jdk1.5支持注解，spring2.5支持注解开发
 
  
使用注解须知：
 
  
1、导入约束（.../context）
 
  
2、配置注解的支持()
 
  
 
   


 

 
 
  
 
  
public class People {

    //如果显示定义了Autowired的rerequired属性为false,说明这个属性可以为null,否则不允许为空
    @Autowired(required = false)
    private Cat cat;
    private Dog dog;
    private String name;

    //表示name可以为空，为空时不报错
    public People(@Nullable String name){
        this.name = name;
    }
}
 
  
 
   
*   用于注入数据：
*       他们的作用和在xml配置文件中bean标签中写一个标签一样
*       @Autowired:
*           作用：自动按照类型注入，只要容器中有唯一一个bean对象类型和要注入的变量类型匹配，就可以注入成功
*                如果IOC容器中没有任何bean的类型和要注入的变量的类型匹配，报错
*                如果IOC容器中有多个类型匹配时：
*           出现位置：
*                  可以是变量上，也可以方法上
*            细节：在使用注解注入时，set方法不是必须的
*        @Qualifier:
*             作用：在按照类中注入的基础之上再按照名称注入。他在给类成员注入时不能单独使用。但是再给方法参数注入时可以。
*             属性：value：用于指定注入bean的id
*       @Resource
*             作用：直接按照bean的id注入，他可以独立使用
*             属性：name,用于指定bean的id
*        以上三个注解都只能注入其他bean类型的数据，而基本数据类型和String类型无法使用上述注解实现。
*        另外，集合类型的注入只能通过XML实现。
*        @Value:
*               作用：用于注入基本类型和String类型的数据
*               属性：value:用于指定数据的值，他可以使用spring的spEl(spring的el表达式)
*                     spEL写法：  ${表达式}
 
  
 
  
 
  
 
 
  
 
  
 
  
 8、使用注解开发
 
  
在Spring4之后，要使用注解开发，必须保证aop的包导入了
 
  
 
  
使用注解需要导入context约束，增加注解的支持。 
 
  
 
  
1、bean
 
  
2、属性如何注入
 
  
 
  
3、衍生注解  
 
  
 
  
 4、自动装配
 
  
 
  
 5、作用域
 
  
 
  
6、小结
 
  
 
  
 9、使用Java的方式配置Spring
 
  
我们现在完全不使用spring的xml配置了，全权交给Java来做
 
  
JavaConfig是spring的一个子项目，在Spring 4之后成为一个核心功能
 
  
 
  
 
  
1、  实体类
 
  
 
  
2、配置类 
 
  
 3、测试类
 
  
 
  
 这种存java配置方式，在springboot随处可见
 
  
10、代理模式
 
  
为什么使用代理模式，因为这是AOP底层
 
  
 10.1、静态代理
 
  
 
  
   
 
  
 
  
/**
 * 租房
 */
public interface Rent {
}

/**
 * 房东
 */
public class Host implements Rent{

    public void rent(){
        System.out.println("房东要出租房子");
    }
}


/**
 * 代理
 */
public class Proxy implements Rent{

    Host host = new Host();

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    public void rent(){
        seeHouse();
        host.rent();
        hetong();
        fare();
    }

    public void seeHouse(){
        System.out.println("中介带你看房");
    }

    public void hetong(){
        System.out.println("中介跟你签合同");
    }

    public void fare(){
        System.out.println("中介收中介费");
    }
}

public class Client {

    public static void main(String[] args) {
        //房东要出租房子
        Host host = new Host();
        //代理，中介帮房东出租房子，有一些附加操作
        Proxy proxy = new Proxy(host);
        //直接找代理
        proxy.rent();
    }
}
 
  
AOP
 
  
【静态代理实战(在所有方法上加个日志)】
 
  
public interface UserService {

    public void add();
    public void delete();
    public void update();
    public void query();
}

package designpattern;

public class UserServiceImpl implements UserService {

    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("更新了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}
package designpattern;

public class UserProxy implements UserService {

    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    public void log (String msg){
        System.out.println("【debug】使用了一个"+msg+"方法");
    }
}
 
  
 
  
10.2、动态代理
 
  
 
  
public class MyInvokeHandler implements InvocationHandler {

    //真实类（被代理类），被代理类接口
    Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //获取代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    //调用方法
    //处理代理实例，并返回结果
    //调用 getProxy 方法会自动调用invoke方法，因为传入InvocationHandler
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target,args);
        return result;
    }

    public void log (String msg){
        System.out.println("执行了"+msg+"方法");
    }

}


public class ClientProxy {

    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色,不存在
        MyInvokeHandler myInvokeHandler = new MyInvokeHandler();

        //设置要代理的对象
        myInvokeHandler.setTarget(userService);
        //生成动态代理类
        UserService proxy = (UserService)myInvokeHandler.getProxy();
        proxy.add();
    }
}
 
  
 
  
 11、AOP
 
  
1、AOP
 
  
 
  
 
  
2、AOP在spring中作用
 
  
 
  
 
  
 
  
3、使用Spring实现AOP 
 
  
业务逻辑 和 增强的代码分开实现
 
  
通过xml 织入关系 
 
  
public interface UserService {

    public Boolean add();
    public void delete();
    public void update();
    public void query();
}

public class UserServiceImpl implements UserService {

    @Override
    public Boolean  add() {
        System.out.println("增加了一个用户");
        return true;
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("更新了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询了一个用户");
    }
}

/**
 * 前置增强
 */
public class Log implements MethodBeforeAdvice {

    /**
     *
     * @param method 要执行目标对象方法
     * @param args  参数
     * @param target  目标
     * @throws Throwable
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName() +"被执行了");
    }
}

/**
 * 后置增强
 */
public class AfterLog implements AfterReturningAdvice {

    /**
     *
     * @param returnValue  返回值
     * @param method  代理对象的方法
     * @param args 方法参数
     * @param target 代理对象
     * @throws Throwable
     */
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"返回结果为："+returnValue);
    }
}
 
  




    
    
    

    
    
        
        

        
        
        
    

 
  
总结：使用切面aspect（类） 中的通知advice （方法） 在切入点pointcut （待增强的方法处）
 
  
public class DiyPointcut {

    public void after(){
        System.out.println("方法之后执行");
    }

    public void before(){
        System.out.println("方法之前执行");
    }
}
 
  

    
    
        
            
            
            
        
    
 
  
12、整合mybatis
 
  
 
  
 
  
12.1、mybatis步骤
 
  
 
  
@Data
public class User {

    private int id;
    private String name;
    private String pwd;
}
 
  




    
        
    
    
    
        
            
            
                
                
                
                
            
        
    

    
        
    
 
  
public interface UserMapper {

    public List selectUser();
}
 
  




    
        select * from mybatis.user;
    

 
  
public class Mytest {

    @Test
    public void test() throws IOException {
        String resources = "mybatis-config.xml";
        InputStream is = Resources.getResourceAsStream(resources);

        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        SqlSession session = factory.openSession(true);

        UserMapper userMapper = session.getMapper(UserMapper.class);
        List users = userMapper.selectUser();

        for (User u:users) {
            System.out.println(u);
        }
    }
}
 
  
问题1:org.apache.ibatis.binding.BindingException: Type interface mybatis.mapper.UserMapper is not known to the MapperRegistry.
 
  
因为需要在配置文件mybatis-config.xml中引入mapper.xml
 
  
    
        
    
 
  
问题2:org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): mybatis.mapper.UserMapper.selectUser
 
  
此时运行后没有在target里生成UserMapper.xml文件
 
  
 方法：在pom中添加
 
  


        
            
                src/main/java
                
                    **/*.xml
                
                true
            
        

    
 
  
 
  
13、Mybatis-Spring整合 
 
  
Spring万物皆注入
 
  
 
  
 
  
1、创建spring-dao.xml文件：spring来管理datasource、sqlsessionfactory、sqlsession、将mapper.xml、mybatis-config.xml也放到spring容器里。
 
  
2、实际上mybatis-config.xml可以省略，但开发中习惯将两项：别名管理alias和设置setting放到mybatis配置文件中。
 
  
3、现在可以直接从spring容器拿到sqlsession等。之前需要new。
 
  
4、mybatis测试时需要先获取sqlSession在获取Mapper，而spring中直接从容器中拿mapper即可。
 
  
5、spring中多个一个实现类，即UserMapper的实现类。因为有了实现类就可以交给spring管理，以bean的形式存在。
 
  
6、正常可以使用applicationContext.xml，该文件作为做外层文件，可以包含spring-dao.xml、spring-web.xml等。
 
  
 13.1、入门
 
  
1、添加依赖 
 
  
 
  
2、 创建bean:sqlSessionFactory
 
  
 
  



    
    
        
        
        
        
    

    
    
        
        
        

        
        
    

    
    
        
    
 
  
 
  
public class UserMapperImpl implements UserMapper{

    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }


    @Override
    public List selectUser() {
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List users = userMapper.selectUser();
        return users;
    }
}

public class Mytest {
    @Test
    public void test() throws IOException {
        //加载配置文件
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper = (UserMapper)applicationContext.getBean("userMapperImpl");
        List users = userMapper.selectUser();
        for (User u:users
             ) {
            System.out.println(u);
        }
    }
 
  
 
  
 14、SqlSessionDaoSupport 
 
  
 
  
1、使用继承父类代替sqlSession的注入。
 
  

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{

    @Override
    public List selectUser() {
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }
}

 
        
    
 
  
15、声明式事务
 
  
 
  
编程式事务
 
  
 声明式事务
 
  
 
  
 
  
以织入的方式配置事务
 
  
spring-dao.xml



    
    
        
        
        
        
    

    
    
        
        
        

        
        
    

    
    
        
    

    
        
    

    
        
    

    
    
        
        
        
            
            
            
            
            
        
    

    
    
        
        
    

 
  
 保证事务生效
 
  

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{

    @Override
    public List selectUser() {
        User user = new User(2,"wang","1234");
        addUser(user);
        deleteUser(2);
        return getSqlSession().getMapper(UserMapper.class).selectUser();
    }

    @Override
    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }

    @Override
    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}
 
  





    
        select * from mybatis.user;
    

    
        insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{pwd})
    


    
        deletes from mybatis.user where id = #{id}