您的位置: 首页  >  文章  >  Java架构师之旅（十九）- 关于ssh

Java架构师之旅（十九）- 关于ssh

分类: 文章 • 2024-03-18 20:00:28

夜光序言：

沉默是弱者最后的尊严，是复仇者最高的轻蔑~~

Java架构师之旅（十九）- 关于ssh

 

 

 

 

正文：

Spring是一个非常活跃的开源框架, 它是一个基于IOC和AOP来构架多层JavaEE系统的框架,它的主要目地是简化企业开发

Spring以一种非侵入式的方式来管理你的代码, Spring提倡”最少侵入”，这也就意味着你可以适当的时候安装或卸载Spring

1、spring模块

Java架构师之旅（十九）- 关于ssh

2、为什么要使用Spring

在项目中引入spring立即可以带来下面的好处 降低组件之间的耦合度,实现软件各层之间的解耦。

Java架构师之旅（十九）- 关于ssh    

IOC(依赖注入)：包含并管理应用对象的配置和生命周期，你可以配置你的每个bean如何被创建，也可以配置每个bean是只有一个实例，还是每次需要时都生成一个新的实例，以及它们是如何相互关联的

AOP(面向切面)：采用了面向切面编程来实现很多基础但是与业务逻辑无关的功能的解耦,比如：事务管理、日志、权限验证..... DAO:Spring 还提供了对数据库JDBC的封装,使用JdbcTemplate来简化数据操作

ORM：提供了对主流的对象关系映射框架的支持

JEE: 对Java企业级开发提供了一些解决方案,例如EJB、JMS等

WEB: 提供了自己的Spring MVC和对显示层框架的集合支持 

=========================================================================================

 

夜光：作为ssh，ssm框架，我们需要了解一些基本的东西

控制反转(IOC)

IOC就是 Inversion Of Control

public class Girl {    

 private Boy boy =new Boy();      

 public void kiss() {          

System.out.println(boy.getName());    

}

}

boy是在应用内部创建及维护的。所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转，目的是为了获得更好的扩展性和良好的可维护性。

依赖注入(DI)

 DI就是 Dependency Injection    当我们把依赖对象交给外部容器负责创建，那么Girl类可以改成如下：

public class Girl

{      

private Boy boy;      

public void kiss()

{          

System.out.println(boy.getName());    

}

}

所谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到另一个对象中。

夜光：框架概述：（SSH），还有SSM我们要在SSH之上学习，对比分析

Struts2:  基于mvc模式的应用层框架！

主要是作为控制层组件，javabean， jsp！

Hibernate: 持久层组件，简化jdbc操作！

Spring:   主要有六大模块功能

 事务管理！

 与其他框架整合！

 

Mvc开发模式：

基于mvc模式的项目分层!

 

框架理解

框架，都会预先实现一些功能，给开发人员开发提供便利！

  提高开发效率、提升程序可扩展性、健壮！

 

专业术语

高内聚、低耦合：

类内部的关系越紧密越好，类与类的关系越少越好！

非侵入式设计：

侵入式设计：

引入的组件对现有的类的结构会有影响，这种就是“侵入式设计”的组件！

Struts2:     侵入式设计！

Hibernate:   非侵入式设计！

非侵入式设计：

引入组件对现有的类的结构没有影响！

Spring, 非侵入式设计

  IOC 容器

Inversion of control  控制反转

控制反转容器!   -à 对象创建的问题！

解释：

User user = new User();  自己控制对象的创建

现在需要对象，自己不创建，交给外部的容器创建，叫控制反转！

IOC容器= bean.xml配置 + ApplicationContext容器类

DI,  dependency  injection 依赖注入

创建对象后，处理对象的依赖关系！

User  user = new User();

user.setAddress(..)  ;// 需要DI（依赖注入）

 

  Aop…

 

Spring框架

Spring 开源框架，提供的是一站式解决方案！

六大模块:

…..

 

 

  1. Spring 第一个案例， 解决项目中如何创建对象

 

1) 引入jar文件 (3.2版本)

commons-logging-1.1.3.jar       【单独下载】

spring-beans-3.2.5.RELEASE.jar 【spring源码, bean节点管理】

spring-context-3.2.5.RELEASE.jar      【spring上下文类】

spring-core-3.2.5.RELEASE.jar         【IOC容器】

spring-expression-3.2.5.RELEASE.jar    【spring表达式】

 

注意：

使用的版本Spring3.2

在这个版本中，只有spring自身的核心功能，spring依赖的其他组件，需要单独下载！ 例如：日志jar文件，就需要单独下载！

 

2) 新建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"

    xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd">

 

</beans>        

 

3) 配置

 

<!-- 创建Dao实例 -->

<bean id="userDao" class="cn.itcast.dao.UserDao"></bean>

 

<!-- 创建Service实例 -->

<bean id="userService" class="cn.itcast.service.UserService">

<property name="userDao" ref="userDao"></property>

</bean>

 

<!-- 创建Action实例 -->

<bean id="userAction" class="cn.itcast.action.UserAction">

<property name="userService" ref="userService"></property>

</bean>

 

4) 测试

// 从IOC容器获取对象

@Test

public void testApp2() throws Exception {

// 容器对象(加载applicationContext.xml配置文件)

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

// 获取对象

UserAction userAction = (UserAction) ac.getBean("userAction");

userAction.execute();

}

 

创建bean细节：

1) bean在容器中的写法

2) bean声明周期

 

 

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

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd">

 

<!-- 把对象加入IOC容器 -->

 

<!--

细节1：

id 与   name：

id 不能以数字开头，不能含有特殊符号, 不能有空格、逗号等；  id 不能重复！

name 可以以数字开头，可以有特殊符合，如果name值重复，编译没有问题但运行报错！

 

<bean id="user" name="user2,user3 user4" class="cn.itcast.a_config.User"></bean>

<bean name="user5" class="cn.itcast.a_config.User"></bean>

<bean id="user6" class="cn.itcast.a_config.User"></bean>

<bean id="user6" class="cn.itcast.a_config.User"></bean>

-->

 

<!-- 细节2： (单例/多例)  -->

<!--

scope="singleton"   默认表示单例！

       prototype    多例

init-method=""      在创建完对象之后执行初始化方法

destroy-method=""   在调用容器类的destroy()方法时候，对单例的对象有效！

lazy-init="true"    延迟初始化 / 这个属性的设置只对单例有影响，对多例没有任何影响！

单例的对象默认是在创建容器的时候就创建所有单例的对象，如果希望在第一次访问的时候创建单例的对象，就设置延迟初始化

Bean生命周期：

   bean在xml中配置，

      singleton  单例

       1) 创建对象

        如果有配置延迟初始化，

         lazy-init=true  如果单例的对象有配置延迟初始化， 在创建容器之后，在第一次从容器获取对象的时候

          创建单例的对象！

       如果没有配置或延迟初始化为默认值, 单例的对象会在创建容器的时候创建对象

    2) 执行初始化方法 , init-method配置的方法会执行

    3) 调用容器destroy() 方法时候，容器在销毁单例对象的实例的时候，会调用destroy-method对应的方法

       此时bean对象会被销毁！

      

      prototype  多例

        1) 每次在从容器获取对象的时候，都会创建新的对象

        2) 每次创建完对象后，就执行初始化方法

     3) java回回收不用资源(jvm gc)

 -->

<bean id="user" 

class="cn.itcast.a_config.User" 

init-method="init" 

destroy-method="destroy_" 

lazy-init="false" 

scope="prototype"></bean>

 

</beans>      

 

 

创建对象的几种方式

 

创建对象的几种方式：

1） 调用无参数构造器

2） 调用有参数构造器

3） 工厂

* 静态方法

<bean id=”’  class=””  factory-method=””/>

* 非静态方法

<bean id=”factory”  class=”..”>

<bean id=””  factory-bean=” factory”   factory-method=”实例方法” />

4)  反射

 

 

处理对象的依赖关系

给对象属性赋值(DI, 依赖注入)，几种方式：

 1) 构造函数赋值

 2) set 方法注入值

* 普通字段赋值

* 集合属性 (list/map/property)

3) 案例

Dao/service/action实例，处理依赖关系

* 常用的通过set方法注入

* 内部bean

* p 名称空间

* 自动装配

* 注解

 

 

 

注解总结：

@Component  表示一个组件(类)，把当前组件加入ioc容器

 加入容器的组件的名称默认是类名第一个字母小写

@Component(“”)   指定加入ioc容器的组件类的类名

 

@Repository    标识是一个持久层的组件

@Service       标识是一个业务逻辑层的组件

@Controller     标识是一个控制层的组件

 

@Scope("prototype") 指定对象单例/多例

@Resource     1. 默认根据修饰的字段名称会取ioc容器找对象自动注入

找到后注入

 如果名称没有找到，再根据类型查找  找到后就立刻注入

如果改类型在ioc容器中有多个对象，报错！

根据类型也没有找到对象，报错！

 

@Resource(name =””) 会根据指定的名称去容器找对象自动注入

 

配置方式与注解方式:

1. 配置， 便于维护

(配置过多，比较繁琐)

2. 注解， 开发方便

(简化配置，不利于后期维护，如果修改对象创建、关系处理，需要改代码！)

 

Spring与struts整合，关键点:

把action的创建，交给spring的ioc容器！

所以，需要引入jar文件：

struts2-spring-plugin-2.3.4.1.jar 【struts源码】

spring-web-3.2.5.RELEASE.jar 【spring源码】

 

整合完整步骤：【有很多细节在之前几个章节也讲过了嗯】

1.  引入jar

Struts核心jar

Spring

Core  核心       （5个）

Web  对web支持 (2个)

2. 配置

bean.xml

struts.xml

web.xml

struts2核心过滤器

启动时候，配置加载springIOC容器

 

3. Action 类

 

 

 

夜光任务：

1. 写简单案例，练习spring 、

* 搭建spring环境

* 测试OK

* dao/service/action

然后处理对象依赖关系，

* set方法注入值, 几种方式

* 注解

2. spring与struts整合，小案例

3. 优化前面项目，

融入spring功能！

 

 

 

相关推荐