js：substring(beginindex, endindex),取得是beginindex到endindex-1位置处的字符串。
java: substring(beginindex, endindex),取得是beginindex到endindex-1位置处的字符串。
c#: substring(beginindex, length),取得是beginindex开始的长度为length的字符串。
比如“0123456”
js： substring(1, 4) 为 “123”
java: substring(1, 4) 为 “123”
c#: substring(1, 4) 为 “1234”
编写Java程序时，我们可能会碰到解释数学表达式的问题，例如，输入字符串“(5+4)*10”，求出其算术结果，对于这个问题，可以通过后缀表达式来解决。
首先，让我们看看后缀表达式的算法：
1) 将中缀表达式转换为后缀表达式：
•当读到数字直接送至输出队列中；
•当读到运算符t时：
a.将栈中所有优先级高于或等于t的运算符弹出，送到输出队列中；
b.t进栈；
•读到左括号时总是将它压入栈中；
•读到右括号时，将靠近栈顶的第一个左括号上面的运算符全部依次弹出，送至输出队列后，再丢弃左括号；
•中缀表达式全部读完后，若栈中仍有运算符，将其送到输出队列中。
2) 运用后缀表达式进行计算：
•建立一个栈S；
•从左到右读后缀表达式，读到数字就将它转换为数值压入栈S中，读到运算符则从栈中依次弹出两个数分别到Y和X，然后以“X 运算符 Y”的形式计算机出结果，再压加栈S中；
•如果后缀表达式未读完，就重复上面过程，最后输出栈顶的数值则为结束。
以下是代码实现：
[code]package wenly.util;
import java.util.Stack;
import java.util.regex.*;
public class StringToArithmetic …{
private StringToArithmetic() …{
}
/** *//**
* 给出一个算术表达式，返回结果。 例如 (5+8+10)*1，返回23
*
* @param string
*/
public static double stringToArithmetic(String string) …{
return postfixExprToArithmetic(prefixExprToPostfixExpr(string));
}
/** *//**
* 中缀表达式转后缀表达式
*
* @param String
* prefix
* @return String
*/
private static String prefixExprToPostfixExpr(String prefix) …{
Stack<Character> stack = new Stack<Character>();
String postfix = "";
int length = prefix.length();
for (int i = 0; i < length; i++) …{
Character temp;
char c = prefix.charAt(i);
switch (c) …{
// 忽略空格
case ' ':
break;
// 碰到'('，push到栈
case '(':
stack.push(c);
break;
// 碰到'+''-'，将栈中所有运算符弹出，送到输出队列中
case '+':
case '-':
while (stack.size() != 0) …{
temp = stack.pop();
if (temp == '(') …{
stack.push('(');
break;
}
postfix += " " + temp;
}
stack.push(c);
postfix += " ";
break;
// 碰到'*''/'，将栈中所有乘除运算符弹出，送到输出队列中
case '*':
case '/':
while (stack.size() != 0) …{
temp = stack.pop();
if (temp == '(' || temp == '+' || temp == '-') …{
stack.push(temp);
break;
} else …{
postfix += " " + temp;
}
}
stack.push(c);
postfix += " ";
break;
// 碰到右括号，将靠近栈顶的第一个左括号上面的运算符全部依次弹出，送至输出队列后，再丢弃左括号
case ')':
while (stack.size() != 0) …{
temp = stack.pop();
if (temp == '(')
break;
else
postfix += " " + temp;
}
postfix += " ";
break;
default:
postfix += c;
}
}
while (stack.size() != 0)
postfix += " " + stack.pop();
return postfix;
}
/** *//**
* 通过后缀表达式求出算术结果
*
* @param String
* postfix
* @return double
*/
private static double postfixExprToArithmetic(String postfix) …{
Pattern pattern = Pattern.compile("\d+||\d+\.\d*"); // 匹配数字
String strings[] = postfix.split(" ");
for (int i = 0; i < strings.length; i++)
strings[i].trim();
Stack<Double> stack = new Stack<Double>();
for (int i = 0; i < strings.length; i++) …{
if (strings[i].equals(""))
continue;
if ((pattern.matcher(strings[i])).matches()) …{
stack.push(Double.parseDouble(strings[i]));
} else …{
double y = stack.pop();
double x = stack.pop();
stack.push(caculate(x, y, strings[i]));
}
}
return stack.pop();
}
private static double caculate(double x, double y, String simble) …{
if (simble.trim().equals("+"))
return x + y;
if (simble.trim().equals("-"))
return x – y;
if (simble.trim().equals("*"))
return x * y;
if (simble.trim().equals("/"))
return x / y;
return 0;
}
}[/code]
这老太太说的言简意赅，一针见血
今天在家呆着学习Spring，随意搜一些关于java的QQ群，加了一个，一个人问了一个题，说是用程序打印出一个圆形，打印一个图形，从刚开始学C语言时，讲到循环那里是必做的题目了，主要有打印一个正三角，打印一个倒三角，还见过一个倒三角下面是一个正三角的图形，这些用for循环都能很好的实现，比如下面两个图形
*
* *
* * *
* * *
* *
*
现在说回这个题目，是打印一个圆形，特殊性在于圆，按照一般规律想，从第一行开始，有圆周围的点的地反，就打印一个* ，可是关键在于圆的特殊性，把打印这种题目再抽象一下，无非就是打印一个空格，或者打印一个* ，从第一行扫描到最后一行就成了一个由空格或者*构成的矩形或者正方形，然后在这个矩形里找到相应图形的点，三角形的话，肯定是可以找到这样的点的，想象一下，圆形的话，是没法找到这样的点，当这个有空格和*构成的正方形无限大时，圆边的点才能无限接近于正方形当中的每个点。
或者换一种描述方式，当把圆的横向平均分成n份的话，纵向的n份肯定不是平均的，纵向的坐标肯定是一个小数，当这个正方形无限大时，那么可以找到越接近这个小数的一个自然数，这样就可以找到坐标了
程序如下：
/**
* @param args
*/
public static void main(String[] args) {
int n=1000;//n越大，才能越接近圆
PrintCircle p = new PrintCircle();
for(int i=0;i<2*n;i++){
p.printPoint(n,i);
}
}
private int[] getXFromY(int y,int n)//n为半径，y<2n,返回2个x
{
if(y<=n){//上半侧
int x1=n-(int)Math.sqrt(n*n-(n–y)*(n–y));
int x2=(int)Math.sqrt(n*n-(n–y)*(n–y))+n;
return new int[]{x1,x2};
}
else if(y<=2*n){//下半侧
int x1=n-(int)Math.sqrt(n*n-(n–y)*(n–y));
int x2=(int)Math.sqrt(n*n-(n–y)*(n–y))+n;
return new int[]{x1,x2};
}
return null;
}
private void printPoint(int n,int y){//半径n,在(x,y)的位置打印一个*
int x1=getXFromY(y,n)[0];
int x2=getXFromY(y,n)[1];
for(int i=0;i<=2*n;i++){
if(i==2*n) System.out.println("\n");
if(i==x1||i==x2) System.out.print("*");
else System.out.print(" ");
}
}
}
我试了一下，n=1000，这个才大概像个圆，n小的话，一般看着大概像个椭圆
如果谁有更好的算法的话，欢迎告诉我:)
应用部署运行的时候出现JSP异常, 发生在使用JSTL库的时候: According to TLD or attribute directive in tag file, attribute value does not accept any expressions, 可能是因为使用了JSP2.0版本, 同时又没有使用JSTL core库的备用版本(RT库), 以下有两种处理方法:
1. 如果不想使用web-app_2_4.xsd 和jstl1.1 那么可以按照下面两种方式修改
1). 修改web.xml.
[code]<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">[/code]改为2.3版本的
[code]<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>[/code]
2). 使用JSTL core RT库
JSTL core库的有两种taglib伪指令, 其中RT库即是依赖于JSP传统的请求时属性值, 而不是依赖于EL来实现(称为EL库.JSP2.0将支持EL)
JSP中使用<%@ taglib uri=http://java.sun.com/jstl/core prefix="c"%>在2.3版本都可以,在2.4就不行了, 这是版本不兼容引起的，稍后将介绍servlet的版本。
只要将
[code]<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c"%>[/code]
改为
[code]<%@ taglib uri=http://java.sun.com/jstl/core_rt prefix="c"%>[/code]
2：如果要使用jstl1.1（推荐） 则按照一下修改，很简单的。
jstl存在1.0和1.1的差异问题，用EL建议需要在1.1的版本下，
使用jstl1.1 只需要将
1.0的为
[code]<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>[/code]
换成：
[code]<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>[/code]
注意，1.0版本没有/jsp/
附录： jsp servlet j2ee tomcat jdk的版本差别
一 JSP2.0与JSP1.2比较
JSP 2.0是对JSP 1.2的升级，新增功能：
1. Expression Language
2. 新增Simple Tag和Tag File
3.web.xml新增<jsp:config>元素
特别说明web.xml.
web.xml新增<jsp:config>元素
<jsp-config> 元素主要用来设定JSP相关配置，<jsp-config> 包括<taglib>和<jsp-property-group>
子元素。
(1)其中<taglib>以前的Jsp1.2中就有的,taglib主要作用是作为页面taglib标签中的uri和tld文件的一个映射关系
(2)其中<jsp-property-group>是JSP2.0种新增的元素。
[code]<jsp-property-group> 主要包括8个子元素，它们分别是：
<jsp-property-group>
<description> [/code]
设定的说明
[code]</description>
<display-name>设定名称</display-name>
<url-pattern>设定值所影响的范围</url-pattern>
<el-ignored>若为true则不支持EL语法<／el-ignored>
<page-encoding>ISO-8859-1</page-encoding>
<scripting-invalid> 若为true则不支持<% scripting%> 语法</scripting-invalid>
<include-prelude>设置JSP网页的抬头,扩展名为.jspf </include-prelude>
<include-coda>设置JSP网页的结尾,扩展名为.jspf</include-coda>
</jsp-property-group>[/code]
例如: 其中抬头程序:
[code]prelude.jspf
<br>
<center>
文本内容
</center>
<hr>
结尾程序:
coda.jspf
<br>
<center>
文本内容
</center>
<hr>[/code]
二、Servlet个版本比较
servlet 2.3 新增功能:
2000年10月份出来
Servlet API 2.3中最重大的改变是增加了filters
servlet 2.4 新增功能:
2003年11月份出来
1、web.xml DTD改用了XML Schema;
Servlet 2.3之前的版本使用DTD作为部署描述文件的定义，其web.xml的格式为如下所示：
[code]<?xml version="1.0" encoding="IS0-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//sunMicrosystems,Inc.//DTD WebApplication 2.3f//EN"
"http://java.sun.com/j2ee/dtds/web-app_2.3.dtd">
<web-app>
…….
</web-app>[/code]
Servlet 2.4版首次使用XML Schema定义作为部署描述文件，这样Web容器更容易校验web.xml语法。同时XML Schema提供了更好的扩充性，其web.xml中的格式如下所示：
[code]<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:workflow="http://www.workflow.com"
xmins:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
………
</web-app>[/code]
注意: 改为Schema后主要加强了两项功能:
(1) 元素不依照顺序设定
(2) 更强大的验证机制
主要体现在:
a.检查元素的值是否为合法的值
b.检查元素的值是否为合法的文字字符或者数字字符
c.检查Servlet,Filter,EJB-ref等等元素的名称是否唯一
2.新增Filter四种设定：REQUEST、FORWARD、INCLUDE和ERROR。
3.新增Request Listener、Event和Request Attribute Listener、Enent。
4.取消SingleThreadModel接口。当Servlet实现SingleThreadModel接口时，它能确保同时间内，只能有一个thread执行此Servlet。
5.<welcome-file-list>可以为Servlet。
6.ServletRequest接口新增一些方法。
public String getLocalName()
public String getLocalAddr()
public int getLocalPort()
public int getRemotePort()
Servlet 2.5的新特征
2005年9月发布Servlet 2.5
Servlet2.5一些变化的介绍：
1） 基于最新的J2SE 5.0开发的。
2） 支持annotations 。
3） web.xml中的几处配置更加方便。
4） 去除了少数的限制。
5） 优化了一些实例
servlet的各个版本对监听器的变化有：
(1)servlet2.2和jsp1.1
新增Listener:HttpSessionBindingListener
新增Event: HttpSessionBindingEvent
(2)servlet2.3和jsp1.2
新增Listener:ServletContextListener,ServletContextAttributeListener
,HttpSessionListener,HttpSessionActivationListener,HttpSessionAttributeListener
新增Event: ServletContextEvent,ServletContextAttributeEvent,HttpSessionEvent
(3)servlet2.4和jsp2.0
新增Listener:ServletRequestListener,ServletRequestAttribureListener
新增Event: ServletRequestEvent,ServletRequestAttributeEvent
三、J2EE规范版本比较
1.J2EE的发展
1997年Servlet技术的产生以及紧接着JSP的产生，为Java对抗PHP，ASP等等服务器端语言带来了筹码。1998年，Sun发布了EJB1.0标准，至此J2EE平台的三个核心技术都已经出现。于是，1999年，Sun正式发布了J2EE的第一个版本。并与1999年底发布了J2EE1.2，在2001年发布了J2EE1.3，2003年发布了J2EE1.4。
2.J2EE1.3
J2EE1.3的架构，其中主要包含了Applet容器，Application Client容器，Web容器和EJB容器，并且包含了Web Component，EJB Component，Application Client Component，以JMS，JAAS，JAXP，JDBC，JAF，JavaMail，JTA等等技术做为基础。
1.3中引入了几个值得注意的功能：Java消息服务（定义了JMS的一组API），J2EE连接器技术（定义了扩展J2EE服务到非J2EE应用程序的标准），XML解析器的一组Java API，Servlet2.3，JSP1.2也都进行了性能扩展与优化，全新的CMP组件模型和MDB（消息Bean）。
3.J2EE1.4
J2EE1.4大体上的框架和J2EE1.3是一致的，1.4增加了对Web服务的支持，主要是Web Service，JAX-RPC，SAAJ，JAXR，还对EJB的消息传递机制进行了完善（EJB2.1）,部署与管理工具的增强（JMX），以及新版本的Servlet2.4和JSP2.0使得Web应用更加容易。
四、Tomcat版本比较
Tomcat 3.x
servlet2.2和jsp1.1标准
Tomcat 4.x
Servlet 2.3 和 JSP 1.2 版本
Tomcat 5.x
Servlet 2.4或2.5 和 JSP 2.0 版本
五、JDK版本比较
已发行的版本:
版本号 名称 中文名 发布日期
JDK 1.1.4 Sparkler 宝石 1997-09-12
JDK 1.1.5 Pumpkin 南瓜 1997-12-13
JDK 1.1.6 Abigail 阿比盖尔–女子名 1998-04-24
JDK 1.1.7 Brutus 布鲁图–古罗马政治家和将军 1998-09-28
JDK 1.1.8 Chelsea 切尔西–城市名 1999-04-08
J2SE 1.2 Playground 运动场 1998-12-04
J2SE 1.2.1 none 无 1999-03-30
J2SE 1.2.2 Cricket 蟋蟀 1999-07-08
J2SE 1.3 Kestrel 美洲红隼 2000-05-08
J2SE 1.3.1 Ladybird 瓢虫 2001-05-17
J2SE 1.4.0 Merlin 灰背隼 2002-02-13
J2SE 1.4.1 grasshopper 蚱蜢 2002-09-16
J2SE 1.4.2 Mantis 螳螂 2003-06-26
J2SE 5.0 (1.5.0) Tiger 老虎
J2SE 5.1 (1.5.1) Dragonfly 蜻蜓
J2SE 6.0 (1.6.0) Mustang 野马
/**
* 阅前说明:
* 此文件为笔者在学习Spring时所写的一些笔记
* 希望能抛砖引玉来促进大家以各种方式交流学习心得
* 如有转载,为了尊重笔者的劳动成果，请保留此段说明
* @author 贺小佼 HeXiaojiao
* Email ld_hxj1@yahoo.com.cn
* QQ 88137099
* Time 2008-04-14 16:43:43
* Blog http://blog.csdn.net/hexiaojiao
*/
Day-01
问题提出：
框架的主要优势是什么？
请简要描述Spring?
Spring框架分为哪几个模块，请详述？
Spring有哪些注入方式，请详细描述？
1.在Setter注入方式中,在beans包下的ProductBean中只加入一个带参数的构造方法会如何？
2.在config.xml中少加一property项会如何？
3.Spring中有哪些集合注入,如何注入？
4.问:如何设置单例模式?有什么作用和特殊效果?
5.问:什么叫混合注入模式,请举例说明?
6.问: Spring中如何进行类型数据的设置
7.问:Spring支不支持数据类型自动转换?构造器复杂情况有哪些？
8.问:如果为嵌套属性(其属性为一个类)时如果配置?(Bean的引用如果配置)
9.问:Bean初始化方案有哪几种,请详述?
10.问:在bean类中(1)初始化接口方案、(2)构造方法与(3)初始化方法方案中各方法的执行顺序如何？
//=======================================================
问题解决:
//——————————————————————-
———-
框架的主要优势是什么？
请简要描述Spring?
Spring框架分为哪几个模块，请详述？
答：Spring框架可分为七个模块,分别如下:
1.核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
2.Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
3.Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
4.Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
5.Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
6.Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 JakartaStruts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
7.Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
//——————————————————————-
———-
Spring有哪些注入方式，请详细描述？
答: 通过注入方式，使程序解耦合
一。通过构造器(构造方法)注入
构造器注入操作步骤:
1.引入Spring架包，建包ioc.common 在这包下建立三个包
ioc.common.beans,ioc.common.config,ioc.common.logic
2.在beans包下建立UserBean类,代码如下:
[code]//UserBean.java
package ioc.common.beans;
public class UserBean …{
private String userName;
private String userPassword;
public UserBean() …{
}
public UserBean(String userName, String userPassword) …{
this.userName = userName;
this.userPassword = userPassword;
}
public String getUserName() …{
return userName;
}
public void setUserName(String userName) …{
this.userName = userName;
}
public String getUserPassword() …{
return userPassword;
}
public void setUserPassword(String userPassword) …{
this.userPassword = userPassword;
}
@Override
public String toString() …{
return userName + "-" + userPassword;
}
}[/code]
3.在config包下建立config.xml文件,内容如下:
[code]
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="userBean" class="ioc.common.beans.UserBean">
<constructor-arg index="0">
<value>Janet </value>
</constructor-arg>
<constructor-arg index="1">
<value>88888888</value>
</constructor-arg>
</bean>
</beans>
[/code]
4.在logic包下建立Run.java,内容如下:
[code]package ioc.common.logic;
import ioc.common.beans.UserBean;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationContext;
public class Run …{
public static void main(String[] args) …{
String fileName = "./src/ioc/common/config/config.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext
(fileName);
// 取得一个实例
UserBean user = (UserBean) ac.getBean("userBean");
System.out.println(user);
}
}
//end of Run.java[/code]
框架:有固定流程的代码集合,代码中的流程能被反复重用
备注:
1.如果构造器(方法)中没有写任何代码又会如何？
答:将会输出 null-null,Spring不关心构造器实现何种功能,只去调用执行;
2.如果没有这个构造器会如何？
答:将会使Spring找不到该构造器而产生异常
Exception in thread “main”
org.springframework.beans.factory.BeanCreationException:
Error creating bean with name ‘userBean’ defined in file
[/home/tarena/corejava/JSP/SpringPrj/./src/ioc/common/config/config.xml]:
2 constructor arguments specified but no matching constructor found in bean ‘userBean’ (hint: specify index and/or type arguments for simple parameters to avoid type ambiguities)
3.如果构造器中有多个参数，没有配置其中某个参数会如何？如何处理？
答:Spring将会产生找不到参数异常,处理方式:建立一个没有该参数的构造器或写入参数
Related cause:org.springframework.beans.factory.UnsatisfiedDependencyException:Error creating bean with name ‘userBean’ defined in file[/home/tarena/corejava/JSP/SpringPrj/./src/ioc/common/config/config.xml]: Unsatisfied dependency expressed through constructor argument with index 1 of type [java.lang.String]: Ambiguous constructor argument types – did you specify the correct bean references as constructor arguments?
Context：包含特定内容的环境
/////////////////////////////////////////////Constructor IOC END
二。 Set注入
1.在步骤一的基础上,在beans包下建立ProductBean类,代码如下:
[code] //ProductBean.java
package ioc.common.beans;
public class ProductBean …{
private String productName;
private String productDiscript;
public void setProductName(String productName) …{
this.productName = productName;
}
public void setProductDiscript(String productDiscript) …{
this.productDiscript = productDiscript;
}
@Override
public String toString() …{
return productName + "-" + productDiscript;
}
}[/code]
2.在config.xml中加入如下内容:
[code] <bean id="productBean" class="ioc.common.beans.ProductBean">
<property name="productName">
<value>Motorolla</value>
</property>
<property name="productDiscript">
<value>mebophone producter</value>
</property>
</bean>[/code]
3.在logic包下新建类RunConstructor代码如下
[code] //RunSetter.java
package ioc.common.logic;
import ioc.common.beans.ProductBean;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationContext;
public class RunSetter …{
public static void main(String[] args) …{
String fileName = "./src/ioc/common/config/config.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext
(fileName);
ProductBean product = (ProductBean) ac.getBean
("productBean");
System.out.println(product);
}
}[/code]
问题:
1.在Setter注入方式中,在beans包下的ProductBean中只加入一个带参
数的构造方法会如何？
答:将会产生异常Spring异常与JVM异常
Exception in thread “main” org.springframework.beans.factory.BeanCreationException:
Error creating bean with name ‘productBean’ defined in file [/home/tarena/corejava/JSP/SpringPrj/./src/ioc/common/config/config.xml]:
Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException:
Could not instantiate bean class [ioc.common.beans.ProductBean]: No default constructor found; nested exception is java.lang.NoSuchMethodException:
ioc.common.beans.ProductBean.
//JVM异常
Caused by: java.lang.NoSuchMethodException:ioc.common.beans.ProductBean.
Tips:强烈建议有不带参数的构造器
2.在config.xml中少加一property项会如何？
答:正常运行，但少加的属性值为null;
3.Spring中有哪些集合注入,如何注入？
答: Spring中有List,Map,Properties,Set,数组(如 String [] ,使用同List)等集合注入;
注入方法:
在配置文件中
形如:
[code] <list>
<value>Eric</value>
<value>Narci</value>
</list>
<map>
<entry key="HR">
<value>人力资源部</value>
</entry>
<entry key="MIS">
<value>信息管理部</value>
</entry>
</map>
<props>
<prop key="GG">成俊杰</prop>
<prop key="MM">伍欣</prop>
</props>
<set>
<value>CoreJava</value>
<value>JDBC</value>
<value>AJAX</value>
</set>[/code]
////////////// END Set注入 END
三。 混合注入
即构造器注入与Set注入方式混合使用
如问题 5.
Tips:如果同时在constractor-arg 和property标签中配置同一属性，
则Setter注入方式会覆盖构造器注入
//—————————————————————————–
4.问:如何设置单例模式?有什么作用和特殊效果?
答:在config.xml中设置
其中singleton=”true”,设定该bean为单例模式;
作用:调用该类的多个对象时只在第一次实例化
特殊效果: 调用时第一次创建对象并赋值，对象还在内存中存活，在第二次或之后创建对象后不用赋值也能调用前面赋予的属性 值。
//———————————————————————-
5.问:什么叫混合注入模式,请举例说明?
答:混合注入模式如:
[code] <constructor-arg index="0">
<value>Janet </value>
</constructor-arg>
<property name="userPassword">
<null />
</property>[/code]
这在构造器中设置用户名，而在Set注入中设置密码
//——————————————————————-
———-
6.问: Spring中如何进行类型数据的设置
答:在配置文件config.xml中进行设置，在value标签中加入属性type=”类型”
———-
7.问:Spring支不支持数据类型自动转换?构造器复杂情况有哪些？
答:支持;如果构造器中参数个数与设置个数相等则调用String参数的构造器,否则自动转换类型再进行调用
如果类型转换失败,则会输出相应出错信息。
//—————————————————————————–
8.问:如果为嵌套属性(其属性为一个类)时如果配置?(Bean的引用如果配置)
答:配置属性形如:
[code] <property name="product">
<ref bean="product"/><!–bean名为此配置文件中的另一个(引用类的)bean中id属性值–>
</property>
<property name="brithday">
<ref bean="date"/>
</property>
<bean id="date" class="java.util.Date"></bean> [/code]
//—————————————————————————–
9.问:Bean初始化方案有哪几种,请详述?
答:有初始化接口方案和初始化方法方案;
方案一:初始化接口方案如下：
9.问:Bean初始化方案有哪几种,请详述?
答:有初始化接口方案和初始化方法方案;
方案一:初始化接口方案如下：
[code] //Bean开发：
package init.beans;
public class User implements InitializingBean …{
private String userName;
public void afterPropertiesSet () throws Exception …{
this.userName = "Google";
System.out.println("++++++++++++1");
}
public String getUserName() …{
return userName;
}
public void setUserName(String userName) …{
this.userName = userName;
}
}[/code]
//config.xml的配置没有任何特殊的地方。如下：
[code]<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="userBean" class="init.beans.UserBean">
<property name="userName">
<value>Eric</value>
</property>
</bean>
</beans>[/code]
[code]//运行调用代码如下 init.logic.RunLogic.java //Google
package init.logic;
import init.beans.UserBean;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationContext;
public class RunLogic …{
public static void main(String[] args) …{
String fileName = "./src/init/config/config.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext
(fileName);
String beanName = "userBean";
Object obj = ac.getBean(beanName);
if (obj != null) …{
UserBean user = (UserBean) obj;
System.out.println(user.getUserName());
}
}
}
//输出结果为
//++++++++++++1
//Google[/code]
[code]package init.logic;
import init.beans.UserBean;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationContext;
public class RunLogic …{
public static void main(String[] args) …{
String fileName = "./src/init/config/config.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext
(fileName);
String beanName = "userBean";
Object obj = ac.getBean(beanName);
if (obj != null) …{
UserBean user = (UserBean) obj;
System.out.println(user.getUserName());
}
}
}
//输出结果为
//++++++++++++1
//Google[/code]
方案二:初始化方法方案步骤如下：
1.在java Bean中加入初始化方法,形如:
[code] //init.beans.UserBean
public String initUser() …{
this.userName = "BaiDu";
System.out.println("*******************2");
return this.userName;
}[/code]
2.在配置文件./src/init/config/config.xml中写入如下内容:
[code]<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="userBean" class="init.beans.UserBean"
init-method="initUser">
<property name="userName">
<value>Eric</value>
</property>
</bean>
</beans>[/code]
3.在调用类执行的方法中写入如下代码：
[code] //init.logic.RunLogic
package init.logic;
import init.beans.UserBean;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationContext;
public class RunLogic …{
public static void main(String[] args) …{
String fileName = "./src/init/config/config.xml";
ApplicationContext ac = new FileSystemXmlApplicationContext
(fileName);
String beanName = "userBean";
Object obj = ac.getBean(beanName);
if (obj != null) …{
UserBean user = (UserBean) obj;
System.out.println(user.getUserName());
}
}
}
//得输出结果为:
//*******************2
//BaiDu[/code]
//—————————————————————————–
10.问:在bean类中(1)初始化接口方案、(2)构造方法与(3)初始化方法方案中
各方法的执行顺序如何？
答:执行顺序:为(2)==>(1)==>(3);
如在UserBean中加入:
[code]public UserBean() …{
System.out.println("#######################0");
}
public String initUser() …{
this.userName = "BaiDu";
System.out.println("*******************2");
return this.userName;
}
public void afterPropertiesSet() throws Exception …{
this.userName = "Google";
System.out.println("++++++++++++1");
}
//结果为:
//#######################0
//++++++++++++1
//*******************2
//BaiDu[/code]
//—————————————————————————–
什么叫依赖注入,控制反转?
依赖配置文件，通过配置文件来赋值，而不是在程序中
当bean某属性为数组时(如String [])如何配置？
答:类似List
[code]<property name="basenames">
<list>
<value>international.config.resources</value>
<!– 可写多个资源文件 –>
</list>
</property>[/code]
//—————————————————————————–
Day 02
1.如何对Spring进行国际化?
2.什么Spring事件模型请举例说明?
//——————————————————————-
———-
如何对Spring进行国际化?
1).建立资源文件
// src/international/config/resources_zh_CN.properties中内容如下：
userinfo={0}\u662f\u4e00\u4e2a\u597d\u4eba
// src/international/config/resources_en.properties中内容如下：
userinfo={0} is a wonderful man
2).建立国际化配置文件 (src/international/config/config.xml)
[code]<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<!–
id 与 class不能改动写死在Spring中类
FileSystemXmlApplicationContext
的getMessage方法中了
–>
<property name="basenames">
<list>
<value>international.config.resources</value>
<!– 可放多套资源文件,其中basenames为String [] 类型 –>
</list>
</property>
</bean>
</beans>[/code]
3).编写测试类(international.logic.Run)
[code]
package international.logic;
import java.util.Locale;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationContext;
public class Run …{
public static void main(String[] args) …{
String sourceFile = "src/international/config/config.xml";
ApplicationContext act = new
FileSystemXmlApplicationContext(sourceFile);
String resolvable = "userinfo";
Object[] paramList = …{ "Eric" };
String msg = act.getMessage(resolvable, paramList,
Locale.getDefault());
// 如果为其他语言找不到其配置文件时,则会加载和操作系统语言一样
的资源文件
//如果也不存在则会出现异常
// 加载顺序 先加载指定语言资源
// 如果失败再尝试加载操作系统语言相应的资源文件
// 如果失败,再加载默认的资源文件
//一旦找到符合的就不再找了
//最后都找不到时抛出异常,不会加载此顺序外的资源文件
System.out.println(msg);
}
}
[/code]
//—————————————END OF 如何对Spring进行国际化?
2.什么Spring事件模型请举例说明?
答: 事件模型包含三类角色，事件触发者，事件和事件接受者;
消息传递方向为,事件触发者==>事件==>事件接受者;
事件模型建立步骤:
1).定义事件
[code]//event.events.WarnEvent
package event.events;
import org.springframework.context.ApplicationEvent;
public class WarnEvent extends ApplicationEvent …{
private static final long serialVersionUID =
3287507907413175457L;
public WarnEvent(Object source) …{
super(source);
}
}[/code]
2).建立事件响应者
[code]//event.listeners.Receiver
package event.listeners;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import event.events.WarnEvent;
public class Receiver implements ApplicationListener …{
public void onApplicationEvent(ApplicationEvent event) …{
System.out.println("Receiver接收到事件＠");
if (true == event instanceof WarnEvent) …{
// 对各种事件的处理
WarnEvent we = (WarnEvent) event;
String msg = (String) we.getSource();
System.out.println("Receiver" + msg);
}
}
}[/code]
[code]
//event.listeners.JaneReceiver
package event.listeners;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import event.events.WarnEvent;
public class JaneReceiver implements ApplicationListener …{
public void onApplicationEvent(ApplicationEvent event) …{
System.out.println("JaneReceiver接收到事件＠");
if (true == event instanceof WarnEvent) …{
// 对各种事件的处理
WarnEvent we = (WarnEvent) event;
long time = we.getTimestamp();
System.out.println("time" + time);
String msg = (String) we.getSource();
System.out.println("JaneReceiver" + msg);
}
}
}
[/code]
3).建立配置文件//src/event/config/config.xml
[code]<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="receiver" class="event.listeners.Receiver"></bean>
<bean id="janereceiver" class="event.listeners.JaneReceiver"></bean>
</beans>[/code]
4).建立事件触发者类
[code]
package event.sender;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationContext;
import event.events.WarnEvent;
public class Run …{
public static void main(String[] args) …{
String sourceFile = "src/event/config/config.xml";
ApplicationContext act = new
FileSystemXmlApplicationContext(sourceFile);
WarnEvent event = new WarnEvent("HaHa");
act.publishEvent(event);
}
}
[/code]
//————————————–2. END
3.问题:什么是AOP?
答:AOP全称是Aspect-Oriented Programming，中文翻译是面向方面的编程或者面向切面的编程。
4.何谓Aspect？
答:Aspect(切面):一个关注点的模块化，这个关注点可能会横切多个对象。
事务管理是J2EE应用中一个关于横切关注点的很好的例子。
在SpringAOP中，切面可以使用通用类(基于模式的风格)
或者在普通类中以@Aspect注解(@Aspect风格)来实现。
即：当前关注的一个代码的流程，其中可能调用了多个类的多个方法。
5.请简述AOP的意义？
答:现在的系统往往强调减小模块之间的耦合度，AOP 技术就是用来帮助实现这一目标的。
从某种角度上来讲“切面”是一个非常形象的描述，它好像在系统的功能之上横切一刀， 要想让系统的功能继续，就必须先过了这个切面。
这些切面监视并拦截系统的行为,在某些(被指定的)行为执行之前或之后执行一些附加的任务(比如记录日志).
而系统的功能流程（比如 Greeting）并不知道这些切面的存在， 更不依赖于这些切面，这样就降低了系统模块之间的耦合度。
先写这些,欢迎经常交流！
回忆：
2009年都快过去2个月了,毕业参加工作到现在也已经近一年半的时候，这一年半我收获了些什么，仔细想想，惊恐的发现我自己都没有办法把它说清楚，心里不由的一惊…感觉从小时候的时候,我就不是一个善于规划的人,母亲常常教导我要给自己制定一个目标，我指定的种种目标都在不到一个月的时间里就放弃了,也算是仗着自己脑子不算太笨,喜欢理科,也就这么一年一年的从小学，初中，高中，考上一个较好的大学，大学毕业后也顺利或者更多的是幸运的进入了一个在旁人看来都很不错的单位，当然我自认为这个单位也是很不错的，初入单位时，雄心壮志要努力工作,拼搏奋斗，生怕自己不能完成工作的任务。可是后来发现工作中需要的知识并不是难买难时，自己渐渐的懈怠下来
那段时间很轻松，心情也好，有一个很好的工作，父母身体健康，还有一个爱自己的女朋友，感觉生活就可以这样下去，白天在单位时有工作的时候就工作，不忙的时候就上网或者听歌之类
|
作用域
|
功能
|
快捷键
|
|
全局
|
查找并替换
|
Ctrl+F
|
|
文本编辑器
|
查找上一个
|
Ctrl+Shift+K
|
|
文本编辑器
|
查找下一个
|
Ctrl+K
|
|
全局
|
撤销
|
Ctrl+Z
|
|
全局
|
复制
|
Ctrl+C
|
|
全局
|
恢复上一个选择
|
Alt+Shift+↓
|
|
全局
|
剪切
|
Ctrl+X
|
|
全局
|
快速修正
|
Ctrl1+1
|
|
全局
|
内容辅助
|
Alt+/
|
|
全局
|
全部选中
|
Ctrl+A
|
|
全局
|
删除
|
Delete
|
|
全局
|
上下文信息
|
Alt+？
Alt+Shift+?
Ctrl+Shift+Space
|
|
Java编辑器
|
显示工具提示描述
|
F2
|
|
Java编辑器
|
选择封装元素
|
Alt+Shift+↑
|
|
Java编辑器
|
选择上一个元素
|
Alt+Shift+←
|
|
Java编辑器
|
选择下一个元素
|
Alt+Shift+→
|
|
文本编辑器
|
增量查找
|
Ctrl+J
|
|
文本编辑器
|
增量逆向查找
|
Ctrl+Shift+J
|
|
全局
|
粘贴
|
Ctrl+V
|
|
全局
|
重做
|
Ctrl+Y
|
|
作用域
|
功能
|
快捷键
|
|
全局
|
放大
|
Ctrl+=
|
|
全局
|
缩小
|
Ctrl+-
|
|
作用域
|
功能
|
快捷键
|
|
全局
|
激活编辑器
|
F12
|
|
全局
|
切换编辑器
|
Ctrl+Shift+W
|
|
全局
|
上一个编辑器
|
Ctrl+Shift+F6
|
|
全局
|
上一个视图
|
Ctrl+Shift+F7
|
|
全局
|
上一个透视图
|
Ctrl+Shift+F8
|
|
全局
|
下一个编辑器
|
Ctrl+F6
|
|
全局
|
下一个视图
|
Ctrl+F7
|
|
全局
|
下一个透视图
|
Ctrl+F8
|
|
文本编辑器
|
显示标尺上下文菜单
|
Ctrl+W
|
|
全局
|
显示视图菜单
|
Ctrl+F10
|
|
全局
|
显示系统菜单
|
Alt+-
|
|
作用域
|
功能
|
快捷键
|
|
Java编辑器
|
打开结构
|
Ctrl+F3
|
|
全局
|
打开类型
|
Ctrl+Shift+T
|
|
全局
|
打开类型层次结构
|
F4
|
|
全局
|
打开声明
|
F3
|
|
全局
|
打开外部javadoc
|
Shift+F2
|
|
全局
|
打开资源
|
Ctrl+Shift+R
|
|
全局
|
后退历史记录
|
Alt+←
|
|
全局
|
前进历史记录
|
Alt+→
|
|
全局
|
上一个
|
Ctrl+,
|
|
全局
|
下一个
|
Ctrl+.
|
|
Java编辑器
|
显示大纲
|
Ctrl+O
|
|
全局
|
在层次结构中打开类型
|
Ctrl+Shift+H
|
|
全局
|
转至匹配的括号
|
Ctrl+Shift+P
|
|
全局
|
转至上一个编辑位置
|
Ctrl+Q
|
|
Java编辑器
|
转至上一个成员
|
Ctrl+Shift+↑
|
|
Java编辑器
|
转至下一个成员
|
Ctrl+Shift+↓
|
|
文本编辑器
|
转至行
|
Ctrl+L
|
|
作用域
|
功能
|
快捷键
|
|
全局
|
出现在文件中
|
Ctrl+Shift+U
|
|
全局
|
打开搜索对话框
|
Ctrl+H
|
|
全局
|
工作区中的声明
|
Ctrl+G
|
|
全局
|
工作区中的引用
|
Ctrl+Shift+G
|
|
作用域
|
功能
|
快捷键
|
|
文本编辑器
|
改写切换
|
Insert
|
|
文本编辑器
|
上滚行
|
Ctrl+↑
|
|
文本编辑器
|
下滚行
|
Ctrl+↓
|
|
作用域
|
功能
|
快捷键
|
|
全局
|
保存
|
Ctrl+X
Ctrl+S
|
|
全局
|
打印
|
Ctrl+P
|
|
全局
|
关闭
|
Ctrl+F4
|
|
全局
|
全部保存
|
Ctrl+Shift+S
|
|
全局
|
全部关闭
|
Ctrl+Shift+F4
|
|
全局
|
属性
|
Alt+Enter
|
|
全局
|
新建
|
Ctrl+N
|
|
作用域
|
功能
|
快捷键
|
|
全局
|
全部构建
|
Ctrl+B
|
|
作用域
|
功能
|
快捷键
|
|
Java编辑器
|
格式化
|
Ctrl+Shift+F
|
|
Java编辑器
|
取消注释
|
Ctrl+\
|
|
Java编辑器
|
注释
|
Ctrl+/
|
|
Java编辑器
|
添加导入
|
Ctrl+Shift+M
|
|
Java编辑器
|
组织导入
|
Ctrl+Shift+O
|
|
Java编辑器
|
使用try/catch块来包围
|
未设置，太常用了，所以在这里列出,建议自己设置。
也可以使用Ctrl+1自动修正。 |
|
作用域
|
功能
|
快捷键
|
|
全局
|
单步返回
|
F7
|
|
全局
|
单步跳过
|
F6
|
|
全局
|
单步跳入
|
F5
|
|
全局
|
单步跳入选择
|
Ctrl+F5
|
|
全局
|
调试上次启动
|
F11
|
|
全局
|
继续
|
F8
|
|
全局
|
使用过滤器单步执行
|
Shift+F5
|
|
全局
|
添加/去除断点
|
Ctrl+Shift+B
|
|
全局
|
显示
|
Ctrl+D
|
|
全局
|
运行上次启动
|
Ctrl+F11
|
|
全局
|
运行至行
|
Ctrl+R
|
|
全局
|
执行
|
Ctrl+U
|
|
作用域
|
功能
|
快捷键
|
|
全局
|
撤销重构
|
Alt+Shift+Z
|
|
全局
|
抽取方法
|
Alt+Shift+M
|
|
全局
|
抽取局部变量
|
Alt+Shift+L
|
|
全局
|
内联
|
Alt+Shift+I
|
|
全局
|
移动
|
Alt+Shift+V
|
|
全局
|
重命名
|
Alt+Shift+R
|
|
全局
|
重做
|
Alt+Shift+Y
|
另外，还有一个常用的快速输入System.out.println的方法，先输入一个sysout ,然后按 Alt+/ 就会自动补全了