Spring

最新推荐文章于 2024-05-03 17:35:14 发布

Lin_XXiang

最新推荐文章于 2024-05-03 17:35:14 发布

阅读量299

点赞数

分类专栏： Spring 文章标签： spring

本文链接：https://blog.csdn.net/Lin_XXiang/article/details/121968373

版权

Spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

总结一句话：Spring就是一个轻量级的（非入侵式）控制反转（IOC），面向切面（AOP）编程的框架！

1、Spring的七大模块：

2、Spring-IOC

3、什么是IOC，本质是什么？

1）什么是ioc（IOC是Spring框架的核心内容）

4、最简单的一个例子

5、IOC创建对象的方式

1、Spring的七大模块：

每个模块的功能如下：

核心容器（Spring Core）：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring 上下文（Spring Context）：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

　　Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境（Web 或 EJB）、独立应用程序、测试环境之间重用。

2、Spring-IOC

之前写代码：UserDao 接口 => UserDaoImpl 实现类 => UserService 业务接口 => UserServiceImpl 业务实现类

弊端：要根据用户的需求就要改原有的代码！！！

// 1、UserDao
public interface UserDao {
    void getUser();
}

// 2、UserDaoImpl 
public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("业务层就做一个事情，调取dao层去查！！！");
    }
}

// 3、UserService 
public interface UserService {
    void getUser();
}

// 4、UserServiceImpl 
public class UserServiceImpl implements UserService{

    private UserDao userDao = new UserDaoOracleImpl();

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

// 5、测试
public class MyTest {
    public static void main(String[] args) {
        //用户实际调用的是业务层，dao层他们不需要接触
        UserService userService = new UserServiceImpl(); 
        userService.getUser();
    }
}

结果：弊端太大，要根据不同的业务更改代码！！！

此时就可以利用set进行动态实现值的注入！（这样就不用自己new一个对象）


public class UserServiceImpl implements UserService{

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

然后测试：

public class MyTest {
    public static void main(String[] args) {
        //用户实际调用的是业务层，dao层他们不需要接触
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoOracleImpl());
        userService.getUser();
    }
}

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码。此时使用set注入后，程序不再具有主动性（主动权交给用户），而是变成了被动的接收对象。这就叫控制反转（IOC的原型就出来了）。这种思想从本质上解决了问题，我们程序就不用再去管理对象的创建。系统的耦合性大大降低！

3、什么是IOC，本质是什么？

1）什么是ioc（IOC是Spring框架的核心内容）

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制

控制反转是一种通过描述（XML或注解），并通过第三方去产生或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法时依赖注入（DI--Dependency Injection）

4、最简单的一个例子

1）新建一个实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Hello {
    private String name;
}

2）在resources路径下创建一个applicaContext.xml文件

其中：bean = 对象 class=“lin.pojo.Hello” 等于new Hello() ---- 原来应该类型变量名 = new 类型();

id = 变量名 class = new 的对象 property 相当于给对象中的属性设置一个值

<?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">

    <!--使用spring来创建对象，在spring中这些都称为bean-->
    <bean id="hello" class="lin.pojo.Hello">
        <property name="name" value="LinKeXiang"></property>
    </bean>
</beans>

3）测试：

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //我们的对象都在Spring中管理，要使用的话直接去里面取
        Object hello = context.getBean("hello");
        System.out.println(hello.toString());
    }
}

这个过程就叫控制反转：

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。

反转：程序本身不创建对象，而变成被动的接收对象。

依赖注入：就是利用set方法来进行注入的。

所谓的IOC就是：对象由Spring来创建，管理，装配！

此时就可以把之前创建的项目使用控制反转来实现一下了！！！

基本内容不变，添加一个applicationContext.xml文件，以及测试类的改变！

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">

    <!--使用spring来创建对象，在spring中这些都称为bean-->
    <bean id="userDaoImpl" class="dao.UserDaoImpl"></bean>
    <bean id="userDaoMySqlImpl" class="dao.UserDaoMySqlImpl"></bean>
    <bean id="userDaoOracleImpl" class="dao.UserDaoOracleImpl"></bean>
    <bean id="userServiceImpl" class="service.UserServiceImpl">
        <!--
            ref : 是引用Spring容器中创建好的对象
            value ： 具体的值，基本数据类型
        -->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>
</beans>

MyTest.class 测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("userServiceImpl");
        userServiceImpl.getUser();
    }
}

此时这里有一个小问题：geiBean时，此时的类型是 Object ，需要强转成你需要的对象

Object userServiceImpl = context.getBean("userServiceImpl");

UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("userServiceImpl");

此时，我们已经彻底不用再程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改！！！

5、IOC创建对象的方式

1）使用无参构造创建对象（默认）

package lin.pojo;


public class User {
    private String name;

    public User(){
        System.out.println("User的无参构造！！！");
    }

    public String getName() {
        return name;
    }

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

    public void show(){
        System.out.println("name="+name);
    }
}

<?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="user" class="lin.pojo.User"></bean>
</beans>

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = (User) context.getBean("user");
        user.show();
    }
}

此时getBean创建了对象，并且使用无参构造来创建！

当User有有参构造时，xml文件会报错

这时候就要使用有参构造创建对象的方法来创建这个对象。（有三种方式）

2）使用有参构造创建对象

【1】用下标的方式：

<bean id="user" class="lin.pojo.User">
        <constructor-arg index="0" value="林XX"/>
</bean>

【2】参数的类型去匹配：（不建议使用）假设有两个String参数，这地方就不行了

<bean id="user" class="lin.pojo.User">
        <constructor-arg type="java.lang.String" value="林XX" />
</bean>

【3】引用另外一个 id，通过 ref 或者 name 去指向一个位置（此时我们的例子构造器的参数就是一个name，所以就用name去指向）

<bean id="user" class="lin.pojo.User">
        <constructor-arg name="name" value="林XX"/>
</bean>

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！

Lin_XXiang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring

总结一句话：Spring就是一个轻量级的（非入侵式）控制反转（IOC），面向切面（AOP）编程的框架！1、Spring的七大模块：每个模块的功能如下：核心容器（Spring Core）：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。 Spring 上下文（Spring Context）：Spring 上...
复制链接

扫一扫