@nextleaf 2018-10-11T01:27:25.000000Z 字数 6823 阅读 836

2018-10-09 工作日志

jQuery AJAX Spring

上午

jQuery Ajax

页面加载时给元素注册事件
jQuery.load(url, [data], [callback])
jQuery.post(url, [data], [callback], [type])
jQuery.getJSON(url, [data], [callback])

//页面加载时给元素注册事件
$(document).ready(function () {
});
//保存数据到服务器，成功时显示信息
$.ajax({
   type: "POST",
   url: "some.php",
   data: "name=John&location=Boston",
   success: function(msg){
     alert( "Data Saved: " + msg );
   }
});
//请求 test.php 网页，传送2个参数，忽略返回值。
$.get("test.php", { name: "John", time: "2pm" } );
//显示 test.cgi 返回值(HTML 或 XML，取决于返回值)，添加一组请求参数。
$.get("test.cgi", { name: "John", time: "2pm" },
          function(data){
          alert("Data Loaded: " + data);
});
//请求 test.php 网页，忽略返回值
$.post("test.php");
//向服务器传递数据数组（同时仍然忽略返回值）
$.post("test.php", { 'choices[]': ["Jon", "Susan"] });
//使用 ajax 请求发送表单数据：
$.post("test.php", $("#testform").serialize());
//输出来自请求页面 test.php 的结果（HTML 或 XML，取决于所返回的内容）
$.post("test.php", function(data){
          alert("Data Loaded: " + data);
          });
//获得 test.php 页面的内容，并存储为 XMLHttpResponse 对象，并通过 process() 这个 JavaScript 函数进行处理
$.post("test.php", { name: "John", time: "2pm" },
          function(data){
          process(data);
          }, "xml");
//获得 test.php 页面返回的 json 格式的内容
$.post("test.php", { "func": "getNameAndTime" },
          function(data){
          alert(data.name); // John
          console.log(data.time); //  2pm
          }, "json");
/*
load(url, [data], [callback])
载入远程 HTML 文件代码并插入至 DOM 中。
默认使用 GET 方式 - 传递附加参数时自动转换为 POST 方式。jQuery 1.2 中，可以指定选择符
url:待装入 HTML 网页网址。
data:发送至服务器的 key/value 数据。在jQuery 1.3中也可以接受一个字符串了。
callback:载入成功时回调函数。
*/
//加载 feeds.html 文件内容
$("#feeds").load("feeds.html");
//以 POST 形式发送附加参数并在成功时显示信息
$("#feeds").load("feeds.php", {limit: 25}, function(){
   alert("The last 25 entries in the feed have been loaded");
 });

下午：

Struts2

Spring

Spring结构

Spring的使用步骤

jar包
applicationContext.xml
JavaBean组件
在xml声明组建
使用Spring容器创建组件

Spring容器的特征

Spring 提供了两种不同类型的容器:

Spring BeanFactory 容器
它是最简单的容器，给 DI 提供了基本的支持，它用 org.springframework.beans.factory.BeanFactory 接口来定义。BeanFactory 或者相关的接口，如 BeanFactoryAware，InitializingBean，DisposableBean，在 Spring 中仍然存在具有大量的与 Spring 整合的第三方框架的反向兼容性的目的。
Spring ApplicationContext 容器
该容器添加了更多的企业特定的功能，例如从一个属性文件中解析文本信息的能力，发布应用程序事件给感兴趣的事件监听器的能力。该容器是由 org.springframework.context.ApplicationContext 接口定义。

ApplicationContext 容器包括 BeanFactory 容器的所有功能，所以通常建议超过 BeanFactory。BeanFactory 仍然可以用于轻量级的应用程序，如移动设备或基于 applet 的应用程序，其中它的数据量和速度是显著

Spring容器创建对象方式：
默认单例模式：scope="singleton"（例如DAO）
原型模式：scope="prototype"（例如Action）

spring容器创建对象时机：
lazy-init=""指定是否延迟创建单例组件，只对单例对象有效

对象的初始化和销毁:
init-method="方法名",此方法会在Spring容器创建对象后自动调用
destroy-method="方法名",此方法会在Spring容器关闭时自动调用(此时使用AbstractApplicationContext接口)

Spring 容器使用依赖注入（DI）来管理组成一个应用程序的组件。这些对象被称为 Spring Beans

2018-10-10

Spring IOC

什么是IOC？
Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。
控制反转是spring的核心，控制反转把原先我们代码里面需要实现的对象创建、依赖的代码，反转给容器来帮忙实现。
对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。
理解：
所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

应用程序需要IoC容器来提供对象需要的外部资源；IoC容器注入应用程序某个它依赖的对象。

Spring IOC 实现原理：
IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。
Java反射（reflection）机制允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，DI就是通过反射来实现注入的。

Spring IOC的使用:
(1) 创建被依赖的组件（通常都是接口类型）

import com.nl.springpracticaltraining.entity.Cost;
import java.util.List;
public interface ICostDao {
    void save(Cost cost);
    void update(Cost cost);
    void delete(int id);
    List<Cost> findAll();
    Cost findById(int id);
}

public class HibernateCostDao implements ICostDao {
//实现接口方法略
public void myinit(){
        System.out.println("初始化HibernateCostDao");
    }
    public void mydestroy(){
        System.out.println("销毁HibernateCostDao");
    }
}

(2) 创建目标组件，并提供接收依赖组件的方式

set方式注入
构造方式注入
以上2种方式注入的对象，使用依赖属性接收

public class AddCostAction {
 //使用接口属性来封装
private ICostDao iCostDao;
 //使用setter方式注入
    public void setiCostDao(ICostDao costDao) {
        System.out.println("使用setter方式注入");
        this.iCostDao = costDao;
    }
/*
//或者构造方式注入:
public AddCostAction(ICostDao iCostDao) {
        this.iCostDao = iCostDao;
        System.out.println("实例化UpdateCostAction(构造方式注入)");
    }
    */
    public String execute(){
        System.out.println("资费修改Action.execute()");
        iCostDao.update(new Cost());
        return "success";
    }
}

(3) 在applicationContext.xml中配置依赖组件和目标组件，以及他们的依赖关系

<!--class可替换为其他技术的实现类，如JDBC，Hibernate-->
<bean id="costDao" class="com.nl.springpracticaltraining.dao.HibernateCostDao" scope="singleton" lazy-init="default"
      init-method="myinit" destroy-method="mydestroy">
    <!--<property name="dataSource" ref="ds"/>-->
</bean>
<!--Action组件使用prototype方式创建对象-->
<bean id="addCostAction" class="com.nl.springpracticaltraining.action.AddCostAction" scope="prototype">
    <!--使用接口属性来封装，使用setter方式注入，ref依赖的组件ID-->
    <property name="iCostDao" ref="costDao"/>
</bean>
<bean id="updateCostAction" class="com.nl.springpracticaltraining.action.UpdateCostAction" scope="prototype">
    <!--使用接口属性来封装，使用构造方式注入，index，构造方法的参数位置，ref=依赖的组件ID-->
    <constructor-arg index="0" ref="costDao"/>
</bean>

(4) 使用Spring容器创建目标组件时，依赖属性就已经有了注入的值了.

@Test
public void updatec() {
    ApplicationContext context = new ClassPathXmlApplicationContext(conf);
    UpdateCostAction updateCostAction = (UpdateCostAction) context.getBean("updateCostAction");
    System.out.println(
            updateCostAction.execute()
    );
}

数据类型的注入：
(1)组件(JavaBean)类型的注入

 <property name="属性名" ref="组件的ID"  />

(2)基本类型的注入

 <property name="属性" value="值"  />

(3) 集合类型(List,Set,Map,Properties)注入

 <!--数据类型的注入-->
    <bean id="personDemo" class="com.nl.springpracticaltraining.entity.PersonDemo">
        <property name="name" value="黄昭鸿"/>
        <property name="age" value="16"/>
        <property name="list">
            <list>
                <value>g1</value>
                <value>g2</value>
                <value>g13</value>
                <value>g14</value>
                <value>g15</value>
                <value>g16</value>
                <value>g17</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>b1</value>
                <value>b2</value>
                <value>b3</value>
                <value>b4</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="g1" value="789456123"/>
                <entry key="g2" value="963852741"/>
                <entry key="g13" value="321654987"/>
                <entry key="g14" value="8524631798"/>
                <entry key="g15" value="7539514682"/>
            </map>
        </property>
        <!--Properties类型-->
        <property name="events">
            <props>
                <prop key="2008">与谁在哪里干了什么事</prop>
                <prop key="2009">与谁在哪里干了什么事</prop>
                <prop key="2010">与谁在哪里干了什么事</prop>
                <prop key="2011">与谁在哪里干了什么事</prop>
                <prop key="2012">与谁在哪里干了什么事</prop>
                <prop key="2013">与谁在哪里干了什么事</prop>
                <prop key="2014">与谁在哪里干了什么事</prop>
                <prop key="2015">与谁在哪里干了什么事</prop>
            </props>
        </property>
    </bean>

注解配置

注解使用的规则
(1)注解需要依附于类，属性，方法
(2)基本语法 "@注解名"

Spring中如何使用注解配置组件
(1) 在applicationContext-annotation.xml的beans标签下，开启对注解的自动扫描

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

开启后，当Spring容器初始化时，它会自动的扫描这个包下所有类中的注解，并将注解配置过的bean纳入Spring容器中，当程序执行时，就可以使用Spring容器来创建这个bean了

(2) 使用注解配置bean
a, 在类上使用注解，标识该类是一个组件，它将被Spring容器管理
@Controller 用于标识Action组件
@Service 用于标识一个业务组件
@Repository 用于标识DAO组件
@Component 用于标识其他的通用组件

b, 在类上使用注解，标识对象的创建方式
@Scope("singleton")

c, 在属性/set方法/构造器上标识依赖的组件

标识属性(@Resource)
//Spring会自动匹配类型并注入，如果找不到类型会报错，如果找到的类型多余一个也会报错

@Resource
private ICostDao costDao;

或

//使用id引用具体的某一个组件
@Resouce(name="jdbcCostDao")
private ICostDao costDao

标识属性(@AutoWired)

@AutoWired
@Qualifier("hibernateCostDao")
private ICostDao costDao

标识set方法

@Resource(name="jdbcCostDao")
public void setCostDao(ICostDao dao){
}

或

@Autowired
@Qulifier("jdbcCostDao")
public void setCostDao(ICostDao dao){
}

标识构造器

@Autowired
public AddCostAction(ICostDao dao){
}

2018-10-09

image_1cpcln62o1ihofsb11qroo310k7n.png-27.4kB
image_1cpclng7n1ri91cj0r9s126r1jh614.png-30.1kB

2018-10-10

image_1cpgbn0ho179oa4shi9d4aol19.png-25.2kB
image_1cpgbn8sq1ndejqv161sbgceo9m.png-53.1kB

2018-10-09 工作日志

上午

jQuery Ajax

下午：

Struts2

Spring

Spring的使用步骤

Spring容器的特征

Spring IOC

注解配置

2018-10-09

2018-10-10

内容目录