SSM -- Spring框架01

一、什么是框架?

框架是一套 第三方 编写的程序,用于解决特定的问题,在使用框架进行开发时,可能并不需要关心某些功能的实现细节,主要掌握正确的使用方式,实现编程的目标。

二、Spring框架的主要作用

Spring框架主要解决了 创建对象 和 管理对象 的问题。

1.创建对象:

在使用Spring框架之前,当需要对象时,通常是利用new关键字来创建一个对象:

 UserDao user = new UserDao();

但由于new对象,会提高类和类之间的依赖关系,即代码的耦合性。

在实际项目中,需要使用到的组件类型会有很多,它们之间也可能存在依赖关系,例如:

public class UserDao {
    void login(){
    }
}
public class UserLoginServlet {
    public UserDao userDao = new UserDao();
    public void doPost(){
        userDao.login();
    }
}

依赖:一个类中的方法在运行时需要另外一个类的对象,则称之为 依赖另外一个类的对象,所以,在此案例中,UserLoginServlet中的doPost方法在运行时需要依赖UserDao的对象。
但是,如果后续UserDao不能满足项目的需求,例如出了更好的框架技术,需要更换成UserMybatisDao类,则在UserLoginServlet类中与UserDao相关的代码都要调整为UserMybatisDao,由于使用到UserDao的类可能有很多个,则在替换过程中,所有涉及UserDao的代码都要调整,则不利于项目的管理和维护!
为了解决这个问题,可以先定义一个接口:

public interface IUserDao {
    void login();
}

让UserDao和UserMybatisDao类实现该接口,例如:

public class UserDao implements IUserDao {
    @Override
 public void login() {   
    }
}
public class UserMybatisDao implements IUserDao {
    @Override
 public void login() {
    }
}

则在UserLoginServlet中,就可以使用接口来声明所需对象,例如:

        //使用接口来声明
        public IUserDao userDao = new UserDao();

注意:在实际开发中,尽量使用接口类型来声明变量!

另外,还可以使用工厂模式来创建类的对象:

public class SpringBeanFactory {
    public IUserDao iuser(){
        return new UserDao();
    }
}

则在各个Servlet组件中,需要使用这些对象时,只需声明:

public IUserDao user = SpringBeanFactory.iuser();

当类需要被替换时,只需要替换工厂类中方法的返回值即可。

以上这种做法使得各Servlet组件不在依赖具体的实现类,而是改为依赖接口,使得类与类之间没有依赖关系了,也称类与类之间没有耦合,所以,这样的做法也称之为“解耦”。

以上总结:使用接口及工厂就可以实现解耦,接口用来声明类型,工厂用于统一生成对象!

三、使用Spring框架管理对象

Spring框架所需的依赖包:

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.8.RELEASE</version>
    </dependency>
    
</dependencies>
1.通过@Bean实现Spring管理类的对象

首先,自定义类,在类中编写一个返回Date类型的对象的方法,在这个方法的声明之前添加 @Bean 注解:

public class SpringBeanFactory {
//@Bean 告诉Spring框架需要调用这个方法,并管理这个方法的返回值对象    
    @Bean
 public Date date(){
        return new Date();
    }
}

接下来,创建一个可以执行的类:

public class SpringTests {
    public static void main(String[] args) {
        //1.加载配置类,获取Spring容器
 AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringBeanFactory.class);
        //2.通过Spring容器创建对象
 Date d = (Date) ac.getBean("date");
        //3.测试
 System.out.println("从Spring容器中获取Date对象:"+d);
        //4.关闭
 ac.close();
    }
}

在以上代码中,调用ac.getBean()方法时,参数date就是Bean的名称。
每个被Spring管理的对象都是一个Bean。

2.通过组件扫描实现Spring管理类的对象

首先,创建一个UserDao类,将类放在某个包中,在类的声明之前添加@Component注解:

package cn.cy.spring;
import org.springframework.stereotype.Component;

@Component
public class UserDao {
}

并不是所有的类都会被当成组件,组件类的特征就是在类的声明之前添加:
@Component:通用
@Controller:建议添加在控制层的声明之前
@Service:建议添加在业务层的声明之前
@Repository:建议添加在持久层或接口的声明之前
这4个注解的作用和使用方式是完全一样的,区别是 语义不同。
接下来,创建一个可以执行的类:

public class SpringTests {
    public static void main(String[] args) {
        //1.加载类,获取Spring容器
 AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext("cn.cy.spring");
        //2.通过Spring容器获取类
 UserDao user = ac.getBean("userDao",UserDao.class);
        //3.测试
 System.out.println(user);
        //4.关闭
 ac.close();
    }
}

在上述代码中,AnnotationConfigApplicationContext类的构造方法中参数cn.cy.spring配置的是Spring执行组件扫描时,扫描的根包。
组件扫描的作用:就是扫描对应的包,以观察是否存在需要被 创建对象 的类,而根包就是包的全类名,在实际执行扫描时,会扫描这个包及其子孙包中所有的类,所以,构造方法中的参数可以是cn,也可以是cn.cy,但尽可能的使用详细的包名。

以上使用到的AnnotationConfigApplicationContext类的构造方法的参数也可以是String...类型的,这个类型是一个可变参数。
可变参数:
在实际调用时,参数的数量是0到n个
如果需要扫描多个包时,可以在构造方法中填写多个参数值,各参数值之间使用逗号(,)分隔

Bean的名称的规则:
1.如果类名的首字母是大写,第二个字母小写,无视其他字母的大小写,Bean的名称就是把首字母小写
2.如果类名的首字母本身就是小写,无视其他字母的大小写,Bean的名称和类名完全相同
3.如果不满足以上规律,则Bean名称和类名完全相同,例如:IUserDao的Bean名称就是IUserDao

其他:
获取Spring容器的两种方式:
第一种方式:AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext("cn.cy.spring"); //构造方法 的参数 就是被创建对象的类所归属的包名
第二种方式(推荐使用):AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);

从Spring容器中获取对象的两种方式:
第一种方式:UserDao u = (UserDao) ac.getBean("dao");//强转
第二种方式(推荐使用):UserDao u = ac.getBean("dao",UserDao.class);//本着能不强转就不强转的原则,如果使用强制转换,则该语句的执行效果永远是强制类型转换,只要类型不匹配,一定会出现ClassCastException 写死了
如果调用其他方法来实现类型转换,在方法体内部是可以进行其它判断,或执行强制类型转换失败后的补救的!

评论

暂无评论