spring第一天

1.SSH框架是怎样来工作的

S—–>SpringMVC/Struts

S—–>Spring(今天要学习的)

H—->Hibernate(已经学过了)

SpringMVC/Struts实际上是Servlet的一个封装 他是为了让为我们快速的能够进行开发controll层

Hibernate/dbutils是解决dao的一个方案 他实际上是JDBC的一个封装 目的的是为了高效的访问我们的数据库

Spring(春天 : 这个表示的是程序员的春天来了…. 在我们的开发中实际上是占有举足轻重的作用 *)

Spring这个团队实际上给我们开发了很多开发中要用到的框架 Spring SprigMVC SpringData SpringBoot SpringCloud

Spring在我们开发中是不是可以整合其余的框架 Hibernate Mybatis Struts Shiro …. 基本上市场上流行的开发框架他提供了整合 还可以给service提供事务 还有其他的功能….

2.MVC开发模式下的工程目录结构回顾

view controll service manager dao 数据库

jsp/html servlet … 处理外部请求 Hibernate/dbutils/jdbc

servlet中 service的对象是从何而来? new newInstance

servie中dao对象是从何而来? new newInstance

平常的时候 我们的JAVA对象从何而来? new

Servlet在开发的时候 Servlet是依赖于 service的

Service在开发的时候 service依赖于 dao的

3. Spring是什么?

Spring是用来解决对象的创建 以及对象之间的依赖关系的

Spring 为我们创建对象 解决对象之间的依赖关系的

4.Spring能干什么?

创建对象

解决依赖

还有就是整合框架

还能为service提供事务

事物的分类

  粗粒度事务

   就是只能够对某一个方法提供的这种事务  称为粗粒度事物   Spring提供的事务就叫做粗粒度的事务

    以后咋们做开发的时候 事务都是用在 service上面的  因为一个操作是否成功是看  整个业务逻辑是否成功


  细粒度事务

   我们前面学习的JDBC的事物就是细粒度事物

   什么是细粒度事物呢?  简单点说  就是可以 对程序的某几行提供事务控制的 这种类型的事务称为  细粒度事物

还可以分成

  本地事务

   我们目前学习的所有的都是本地事务  --->只是操作 一个数据库


   全局事务
       1>:招商银行---->建设银行    这种就系需要使用  全局的事务  因为数据库不一样

5.七大模块

Spring AOP

面向切面的编程

就是将重复代码抽取出来形成一个类 这个类就叫做切面类 然后在需要用到这个类里面某个方法的地方 通过代理模式 动态的植入这个抽取出来的代码的这种编程思想 就叫做 面向切面编程

Spring ORM

是Spring提供的整合 Hibernate Mybatis JPO …ORM框架的这个模块

Spring DAO

这个模块是用来提供的 访问数据库的模块 也就是说这个模块就有点相当于 dbutils/jdbc/hibernate

在Spring中提供的访问数据库的方法

Spring WEB

这个实际上是提供的对web的支持

Spring Context

这个提供的是对上下文的支持

Spring WEB MVC

这个是就是传说中的 Spring MVC 也就是说Spring MVC实际上只是 Spring的一个模块而已 ===Servlet/Struts

6.Spring的HelloWorld程序

1>:要使用我们的Spring编写程序的第一步:下载jar包 spring-framework-4.3.7.RELEASE-dist.jar

commons-logging-1.1.3.jar:日志相关的包 是用来辅助运行的

spring-beans-4.3.7.RELEASE.jar:生成对象的相关包

spring-context-4.3.7.RELEASE.jar:这个是上下文相关的包

spring-core-4.3.7.RELEASE.jar:核心功能包

spring-expression-4.3.7.RELEASE.jar:表达式相关的包

2>:导入我们的核心功能包

3>:在我们src下面编写一个名字叫做 随便取名 的 bean.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:p="http://www.springframework.org/schema/p"
    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">


  <!--自动生成对象-->
  <bean id="user_01" class="com.qf.helloword.User"></bean>

    </beans>

4>:使用API获取这个对象

第一种模式

   public void test() throws Exception {

    //有两种模式来获取这个JAVA对象  
    //第一种  通过工厂模式来获取JAVA对象
    //框架默认的路径就在src下
    ClassPathResource resource=new ClassPathResource("bean.xml");
    //获取这个工厂
    XmlBeanFactory factory=new XmlBeanFactory(resource);
    //第三步:获取这个JAVA对象
    User user=(User) factory.getBean("user_01");
    System.out.println(user);
}

第二种模式

   public void test2() throws Exception {   
    ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
    //第三步:获取这个JAVA对象
    User user=(User) context.getBean("user_01");
    System.out.println(user);
}

Spring的IOC/DI配置

现在这个对象默认是没有构造函数/没有说明到底是单例的与否….

1>:默认情况下 生成的JAVA对象是单例的

配置

 <!--自动生成对象
  scope="prototype":这个就表示的是多例的
  singleton:这个表示的是单例的
  lazy-init:表示的是是否延迟创建对象    这个只是对单例有效  如果不延迟创建那么在web工程中启动工程就会自动创建  如果延迟那么表示的是使用的时候才创建对象

–>

假设我想给我们的对象赋值  怎么办?

调用有参数的构造器

<bean id="user_01" class="com.qf.helloword.User">
<!--这个表示调用的是有多个参数的构造器   index:表示的是参数的下标    value代表的是这个值-->

<!-- <constructor-arg name="userName" value="小波波"></constructor-arg>
<constructor-arg name="userPassword" value="密码小波波"></constructor-arg> -->

下面引用字符串

 <!--假设我要在容器中放入 字符串的对象可不可以直接赋值呢?-->

<bean id="user_02" class="com.qf.helloword.User">
  <constructor-arg index="0" ref="userName"></constructor-arg>
  <constructor-arg index="1" ref="userPassword"></constructor-arg>
</bean>

工厂的模式来创建对象

<!--非静态的方法来生成对象-->
<bean id="factory" class="com.qf.helloword.UserFactory"></bean>
<!--省传入那个工厂里面指定方法的对象-->
<bean id="getNoStaticUser" factory-bean="factory" factory-method="getUserByNOStaticFacory"></bean>


<!--通过静态的方法来生成对象-->
<bean id="getStaticUser" class="com.qf.helloword.UserFactory" factory-method="getUserByStaticFacory"></bean>

接下来我们研究下获取对象的API

ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext(“bean.xml”);
//第三步:获取这个JAVA对象
//如果使用了类型来找这个对象的话那么 在IOC容器里面就只能有一个类型的对象才能找到
//User user=(User) context.getBean(User.class);

    //通过名字来找  最稳定的

// User user=(User) context.getBean(“user_01”);

    //System.out.println(user);

注意:使用Spring的时候 默认调用的是无参数的构造参数

DI的配置

set 方法进行注入

1>:在需要对象的地方申明我们的类的成员变量

//Set注入的第一步:申明成员变量
private UserDao userDao=null;
//第二步:为成员变量生成set方法
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}
//第三步:在我们的bean.xml中进行如下配置

p标签进行注入

 1>:在需要对象的地方申明我们的类的成员变量

//Set注入的第一步:申明成员变量
private UserDao userDao=null;
//第二步:为成员变量生成set方法
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}
<bean id="userDao" class="com.qf.di.UserDao"></bean>
 <!--p标签注入-->
 <bean id="userService" class="com.qf.di.UserService" p:userDao-ref="userDao"></bean>

内部bean的形式进行注入(基本不用)

  <!--内部bean-->

  <bean id="userService" class="com.qf.di.UserService">
    <property name="userDao">
      <bean class="com.qf.di.UserDao"></bean>
    </property>
  </bean>

自动装配

   <!--自动装配-->
   <bean id="userDao" class="com.qf.di.UserDao"></bean>
   <!--name是通过名字找-->
   <!-- <bean id="userService" class="com.qf.di.UserService" autowire="byName"></bean> -->
   <!--通过类型找  那么在IOC的 容器中只能有一个对象  有多个的话那么会报错-->
   <bean id="userService" class="com.qf.di.UserService" autowire="byType"></bean>

还可以设置全局的自动装配

注解模式的使用

1>:配置扫描器

 <context:component-scan base-package="com.qf.anotation"></context:component-scan>

2>将对象放置到IOC容器呢?

@Component @Service @Repository

3>:注对象

@Resource @Autowired