2011年7月21日
1.必须安装nodejs
2.安装cnpm用cnpm替代npm
地址：http://npm.taobao.org/
安装cnpm:
npm install -g cnpm --registry=https://registry.npm.taobao.org
3、用yarn替代npm
yarn的安装：
第一种方法：参考官方文档https://yarn.bootcss.com/
第二种方法：cnpm install -g yarn 或者 npm install -g yarn
4、搭建React开发环境的第一种方法（老-现在推荐）：
https://reactjs.org/docs/create-a-new-react-app.html
1、必须要安装nodejs 注意：安装nodejs稳定版本 教程中的nodejs版本:v8.11.2 教程中的npm版本:v5.6.0
2.安装脚手架工具 （单文件组件项目生成工具） 只需要安装一次
npm install -g create-react-app / cnpm install -g create-react-app
3.创建项目 （可能创建多次）
找到项目要创建的目录：
create-react-app reactdemo
4.cd 到项目里面
cd reactdemo
npm start yarn start运行项目
npm run build yarn build 生成项目
5、搭建React的开发环境的第二种方法（新-未来推荐）：
https://reactjs.org/docs/create-a-new-react-app.html
1、必须要安装nodejs 注意：安装nodejs稳定版本 教程中的nodejs版本:v8.11.2 教程中的npm版本:v5.6.0
2.安装脚手架工具并创建项目
找到项目要创建的目录执行：
npx create-react-app reactdemo
4.cd 到项目里面
cd reactdemo
npm start 运行项目（调试）
npm run build 生成项目（发布）
npx介绍：
npm v5.2.0引入的一条命令（npx），引入这个命令的目的是为了提升开发者使用包内提供的命令行工具的体验。
详情：
npx create-react-app reactdemo这条命令会临时安装 create-react-app 包，命令完成后create-react-app 会删掉，不会出现在 global 中。下次再执行，还是会重新临时安装。
npx 会帮你执行依赖包里的二进制文件。
再比如 npx http-server 可以一句话帮你开启一个静态服务器
posted @
2020-04-16 15:25 Terry Zou 阅读(298) |
评论 (0) |
编辑 收藏
PostConstruct注释用于在完成依赖项注入以执行任何初始化之后需要执行的方法。必须在类投入使用之前调用此方法。
所有支持依赖注入的类都必须支持此注释。即使类没有请求注入任何资源，也必须调用使用PostConstruct注释的方法。
只有一个方法可以使用此批注进行批注。
应用PostConstruct注释的方法必须满足以下所有条件：除了拦截器之外，方法绝不能有任何参数，在这种情况下它采用Interceptor规范定义的InvocationContext对象。
在拦截器类上定义的方法必须具有以下签名之一：
void <METHOD>（InvocationContext）Object <METHOD>（InvocationContext）抛出异常注意：
PostConstruct拦截器方法不能抛出应用程序异常，但可以声明它抛出检查异常，包括java.lang.Exception，
如果相同的拦截器方法除了生命周期事件之外插入业务或超时方法。
如果PostConstruct拦截器方法返回一个值，容器将忽略它。
在非拦截器类上定义的方法必须具有以下签名：void <METHOD>（）应用PostConstruct的方法可以是public，protected，package private或private。
除应用程序客户端外，该方法绝不能是静态的。
该方法可能是最终的。如果该方法抛出一个未经检查的异常，那么该类绝不能投入使用，除非EJB可以处理异常甚至从它们恢复的EJB
然后就会思考问题，这个注释是修饰初始化之后需要执行的方法，那么它和@Autowired、构造函数的执行顺序是什么呢？（当然注释中已经说明了PostConstruct注释用于在完成依赖项注入之后）
@Service
public class BeanA {
@Autowired
private BeanB beanB;
public BeanA() {
System.out.println("这是Bean A 的构造方法");
}
@PostConstruct
private void init() {
System.out.println("这是BeanA的 init 方法");
beanB.testB();
}
}
@Service
public class BeanB {
@PostConstruct
private void init() {
System.out.println("这是BeanB 的init 方法");
}
public BeanB() {
System.out.println("这是Bean B的 构造方法");
}
void testB() {
System.out.println("这是Bean B 的 testB 方法");
}
}
启动后输出:
这是Bean A 的构造方法
这是Bean B的 构造方法
这是BeanB 的init 方法
这是BeanA的 init 方法
这是Bean B 的 testB 方法
所以得到结论： 构造方法 > @Autowired > @PostConstruct
posted @
2020-04-09 15:29 Terry Zou 阅读(299) |
评论 (0) |
编辑 收藏1、ApplicationContext
Spring的核心，Context我们通常解释为上下文环境。ApplicationContext则是应用的容器。 Spring把Bean（object）放在容器中，需要用就通过get方法取出来。在ApplicationContext接口的众多实现类中，有3个是我们经常用到的（见表1-1），并且使用这3个实现类也基本能满足我们Java EE应用开发中的绝大部分需求。
表1-1 ApplicationContext接口的常用实现类介绍
2、ApplicationEvent
是个抽象类，里面只有一个构造函数和一个长整型的timestamp。其源码如下
public abstract class ApplicationEvent extends EventObject {
/** use serialVersionUID from Spring 1.2 for interoperability */
private static final long serialVersionUID = 7099057708183571937L;
/** System time when the event happened */
private final long timestamp;
/**
* Create a new ApplicationEvent.
* @param source the object on which the event initially occurred (never {@code null})
*/
public ApplicationEvent(Object source) {
super(source);
this.timestamp = System.currentTimeMillis();
}
/**
* Return the system time in milliseconds when the event happened.
*/
public final long getTimestamp() {
return this.timestamp;
}
}
3、ApplicationListener是一个接口，里面只有一个onApplicationEvent方法。如果在上下文中部署一个实现了ApplicationListener接口的bean,那么每当在一个ApplicationEvent发布到 ApplicationContext时，调用ApplicationContext.publishEvent()方法，这个bean得到通知。类似于Oberver设计模式。
其源码如下：
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
/**
* Handle an application event.
* @param event the event to respond to
*/
void onApplicationEvent(E event);
}
下面举个例子
自定义事件NotifyEvent:
import org.springframework.context.ApplicationEvent;
public class NotifyEvent extends ApplicationEvent {
private String email;
private String content;
public NotifyEvent(Object source){
super(source);
}
public NotifyEvent(Object source,String email,String content){
super(source);
this.email = email;
this.content = content;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
定义监听器NotifyListener:
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
@Configuration
public class NotifyListener implements ApplicationListener<NotifyEvent>{
@Override
public void onApplicationEvent(NotifyEvent event) {
System.out.println("邮件地址：" + event.getEmail());
System.out.println("邮件内容：" + event.getContent());
}
}
单元测试类ListenerTest： import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.context.WebApplicationContext;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ServerLauncher.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ListenerTest {
@Autowired
private WebApplicationContext webApplicationContext;
@Test
public void testListener(){
NotifyEvent event = new NotifyEvent("object","abc@qq.com","This is the content");
webApplicationContext.publishEvent(event);
}
}
posted @
2020-04-09 14:47 Terry Zou 阅读(1264) |
评论 (0) |
编辑 收藏之前用户使用的是3个注解注解他们的main类。分别是@Configuration,@EnableAutoConfiguration,@ComponentScan。由于这些注解一般都是一起使用，spring boot提供了一个统一的注解@SpringBootApplication。
@SpringBootApplication = (默认属性)@Configuration + @EnableAutoConfiguration + @ComponentScan。
@SpringBootApplication
public class ApplicationMain {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
分开解释@Configuration,@EnableAutoConfiguration,@ComponentScan。
1、@Configuration：提到@Configuration就要提到他的搭档@Bean。使用这两个注解就可以创建一个简单的spring配置类，可以用来替代相应的xml配置文件。
<beans>
<bean id = "car"
class="com.test.Car">
<property name="wheel" ref = "wheel"></property>
</bean>
<bean id = "wheel"
class="com.test.Wheel"></bean>
</beans>
相当于：
@Configuration
public class Conf {
@Bean
public Car car() {
Car car = new Car();
car.setWheel(wheel());
return car;
}
@Bean
public Wheel wheel() {
return new Wheel();
}
}
@Configuration的注解类标识这个类可以使用Spring IoC容器作为bean定义的来源。@Bean注解告诉Spring，一个带有@Bean的注解方法将返回一个对象，该对象应该被注册为在Spring应用程序上下文中的bean。
2、@EnableAutoConfiguration：能够自动配置spring的上下文，试图猜测和配置你想要的bean类，通常会自动根据你的类路径和你的bean定义自动配置。
3、@ComponentScan：会自动扫描指定包下的全部标有@Component的类，并注册成bean，当然包括@Component下的子注解@Service,@Repository,@Controller。
posted @
2020-04-09 09:10 Terry Zou 阅读(119) |
评论 (0) |
编辑 收藏package com.zhihe.xqsh.utils;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.List;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.HttpVersion;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.params.ConnRouteParams;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.impl.cookie.BasicClientCookie;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.util.EntityUtils;
import com.zhihe.xqsh.network.ServerErrorException;
import android.accounts.NetworkErrorException;
import android.annotation.SuppressLint;
import android.util.Log;
public class CustomerHttpClient {
private static final String TAG = CustomerHttpClient.class.getSimpleName();
private static DefaultHttpClient customerHttpClient;
private CustomerHttpClient() {
}
public static synchronized HttpClient getHttpClient() {
if (null == customerHttpClient) {
HttpParams params = new BasicHttpParams();
// 设置�?��基本参数
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, "UTF-8");
HttpProtocolParams.setUseExpectContinue(params, true);
HttpProtocolParams.setUserAgent(params, "Mozilla/5.0(Linux;U;Android 2.2.1;en-us;Nexus One Build.FRG83) "
+ "AppleWebKit/553.1(KHTML,like Gecko) Version/4.0 Mobile Safari/533.1");
// 超时设置
/* 从连接池中取连接的超时时�?*/
ConnManagerParams.setTimeout(params, 2000);
ConnManagerParams.setMaxTotalConnections(params, 800);
/* 连接超时 */
HttpConnectionParams.setConnectionTimeout(params, 5000);
/* 请求超时 */
HttpConnectionParams.setSoTimeout(params, 10000);
// 设置我们的HttpClient支持HTTP和HTTPS两种模式
SchemeRegistry schReg = new SchemeRegistry();
schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schReg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
// 使用线程安全的连接管理来创建HttpClient
ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, schReg);
// �?��连接数：ConnManagerParams.setMaxTotalConnections(params, 50);
customerHttpClient = new DefaultHttpClient(conMgr, params);
}
return customerHttpClient;
}
/**
* 以get方式提交数据
*
* @param url 提交地址
* @param params 参数
* @return 响应结果
* @throws ServerErrorException 请求失败
* @throws NetworkErrorException 连接失败
*/
public static String get(String url, String params) throws ServerErrorException, NetworkErrorException {
int tryTimes = 0;
NullPointerException ex;
do {
try {
return tryGet(url, params);
} catch (NullPointerException e) {
ex = e;
tryTimes++;
}
} while (tryTimes < 3);
throw ex;
}
/**
* 以get方式提交数据
*
* @param url 提交地址
* @param params 参数
* @return 响应结果
* @throws ServerErrorException 请求失败
* @throws NetworkErrorException 连接失败
*/
public static String tryGet(String url, String params) throws ServerErrorException, NetworkErrorException {
try {
HttpGet request = new HttpGet(url + params);
/*if (LotteryApplication.isCmwap()) {
org.apache.http.HttpHost proxy = new org.apache.http.HttpHost("10.0.0.172", 80, "http");
HttpParams httpParams = new BasicHttpParams();
ConnRouteParams.setDefaultProxy(httpParams, proxy);
request.setParams(httpParams);
}*/
HttpClient client = getHttpClient();
HttpResponse response = client.execute(request);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
throw new ServerErrorException("��������æ�����Ժ�����");
}
HttpEntity resEntity = response.getEntity();
String result = (resEntity == null) ? null : EntityUtils.toString(resEntity, "UTF-8");
return result;
} catch (UnsupportedEncodingException e) {
logw(e.getMessage());
return null;
} catch (ClientProtocolException e) {
logw(e.getMessage());
return null;
} catch (IOException e) {
throw new NetworkErrorException("���Ӳ��ɹ���������������", e);
}
}
private static void logw(String string) {
if (string != null) {
Log.w(TAG, string);
}
}
/**
* 以post方式提交数据
*
* @param url 提交地址
* @param params 参数
* @return 响应结果
* @throws ServerErrorException 请求失败
* @throws NetworkErrorException 连接失败
*/
public static String post(String url, List<NameValuePair> params) throws ServerErrorException, NetworkErrorException {
return post(url, params, null);
}
/**
* 以post方式提交数据
*
* @param url 提交地址
* @param params 参数
* @param soTimeout 响应超时时间，单位毫�?
* @return 响应结果
* @throws ServerErrorException 请求失败
* @throws NetworkErrorException 连接失败
*/
public static String post(String url, List<NameValuePair> params, int soTimeout) throws ServerErrorException,
NetworkErrorException {
HttpParams httpParams;
if (soTimeout <= 0) {
httpParams = null;
} else {
httpParams = new BasicHttpParams();
HttpConnectionParams.setSoTimeout(httpParams, soTimeout);
}
return post(url, params, httpParams);
}
/**
* 以post方式提交数据
*
* @param url 提交地址
* @param params 参数
* @param httpParams http参数
* @return 响应结果
* @throws ServerErrorException 请求失败
* @throws NetworkErrorException 连接失败
*/
public static String post(String url, List<NameValuePair> params, HttpParams httpParams) throws ServerErrorException,
NetworkErrorException {
int tryTimes = 0;
NullPointerException ex;
do {
try {
return tryPost(url, params, httpParams);
} catch (NullPointerException e) {
ex = e;
tryTimes++;
}
} while (tryTimes < 3);
throw ex;
}
/**
* 以post方式提交数据
*
* @param url 提交地址
* @param params 参数
* @param httpParams http参数
* @return 响应结果
* @throws ServerErrorException 请求失败
* @throws NetworkErrorException 连接失败
*/
public static String tryPost(String url, List<NameValuePair> params, HttpParams httpParams) throws ServerErrorException,
NetworkErrorException {
try {
HttpPost request = new HttpPost(url);
if (params != null && params.size() > 0) {
request.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
}
// if (LotteryApplication.isCmwap()) {
// org.apache.http.HttpHost proxy = new org.apache.http.HttpHost("10.0.0.172", 80, "http");
// if (httpParams == null)
// httpParams = new BasicHttpParams();
// ConnRouteParams.setDefaultProxy(httpParams, proxy);
// }
if (httpParams != null)
request.setParams(httpParams);
//Log.v("CS", params.toString());
HttpClient client = getHttpClient();
HttpResponse response = client.execute(request);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
//Log.v("CS", params.toString());
//Log.v("CS", response.getStatusLine().getStatusCode() + "");
request.abort();
throw new ServerErrorException("��������æ�����Ժ�����");
}
if (response.getStatusLine ().getStatusCode () != 200) {
request.abort(); //�ж�����,���������Կ�ʼ��һ������
return null;
}
HttpEntity resEntity = response.getEntity();
String result = (resEntity == null) ? null : EntityUtils.toString(resEntity, "UTF-8");
//Log.v("CS", params.toString() + "||||" + result);
return result;
} catch (UnsupportedEncodingException e) {
logw(e.getMessage());
return null;
} catch (ClientProtocolException e) {
logw(e.getMessage());
return null;
} catch (IOException e) {
throw new NetworkErrorException(e.getMessage(), e);
//throw new NetworkErrorException("连接不成功，请检查网络设�?, e);
}
}
@SuppressLint("SdCardPath")
public static String download(String url) throws ServerErrorException, NetworkErrorException {
try {
//Log.i("http-download", url);
HttpPost request = new HttpPost(url);
HttpClient client = getHttpClient();
HttpResponse response = client.execute(request);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
throw new ServerErrorException("��������æ�����Ժ�����");
}
HttpEntity entity = response.getEntity();
InputStream is = entity.getContent();
if (is == null)
throw new ServerErrorException("stream is null ");
String fileExt = url.substring(url.lastIndexOf(".") + 1, url.length()).toLowerCase();
String fileName = url.substring(url.lastIndexOf("/") + 1, url.lastIndexOf("."));
File tempFile = new File("/sdcard/" + fileName + "." + fileExt);
if (!tempFile.exists())
tempFile.createNewFile();
FileOutputStream fileOutputStream = new FileOutputStream(tempFile);
byte[] buf = new byte[1024];
int ch;
while ((ch = is.read(buf)) != -1) {
fileOutputStream.write(buf, 0, ch);
}
fileOutputStream.flush();
fileOutputStream.close();
return tempFile.getAbsolutePath();
} catch (UnsupportedEncodingException e) {
logw(e.getMessage());
return null;
} catch (ClientProtocolException e) {
logw(e.getMessage());
return null;
} catch (IOException e) {
throw new NetworkErrorException(e.getMessage(), e);
}
}
/**
* 清空cookie
*/
public static void clearCookie() {
if (customerHttpClient != null)
customerHttpClient.getCookieStore().clear();
}
/**
* 清除指定cookie
*
* @param name cookie名称
*/
public static void clearCookie(String name) {
if (customerHttpClient == null)
return;
BasicClientCookie expiredCookie = new BasicClientCookie(name, "null");
expiredCookie.setExpiryDate(new Date(System.currentTimeMillis() - 1000));
customerHttpClient.getCookieStore().addCookie(expiredCookie);
}
}
posted @
2015-07-13 22:10 Terry Zou 阅读(267) |
评论 (0) |
编辑 收藏
http://yunpan.cn/ccdbTgQaYa4U7
posted @
2015-07-13 11:04 Terry Zou 阅读(135) |
评论 (0) |
编辑 收藏private Drawable img_time_filter,img_time_filter_selected ;
//过滤器TextView中显示的图片
img_time_filter = getResources().getDrawable(R.drawable.time_filter);
//调用setCompoundDrawables时，必须调用Drawable.setBounds()方法,否则图片不显示
img_time_filter.setBounds(0, 0, img_time_filter.getMinimumWidth(), img_time_filter.getMinimumHeight());
img_time_filter_selected = getResources().getDrawable(R.drawable.time_filter_selected);
img_time_filter_selected.setBounds(0, 0, img_time_filter_selected.getMinimumWidth(), img_time_filter_selected.getMinimumHeight());
tv_filterTime.setCompoundDrawables(img_time_filter_selected, null, null, null);
tv_filterTime.setTextColor(getResources().getColor(R.color.white));
rl_filterTime.setBackgroundColor(getResources().getColor(R.color.red));
tv_filterTime.setCompoundDrawables(img_time_filter, null, null, null);
rl_filterTime.setBackgroundColor(getResources().getColor(R.color.white));
lv_filterTime.setVisibility(View.INVISIBLE);
posted @
2015-07-09 00:04 Terry Zou 阅读(201) |
评论 (0) |
编辑 收藏<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@color/white"
android:orientation="vertical" >
<com.baidu.mapapi.map.MapView
android:id="@+id/bmapView_routePlanActivity"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:clickable="true" />
<LinearLayout
android:layout_width="match_parent"
android:layout_height="60dp"
android:background="@drawable/common_title_back"
android:gravity="center"
android:padding="5dp" >
<Button
android:id="@+id/button_transit_routePlan"
android:layout_width="0dp"
android:drawableLeft="@drawable/ic_bus"
android:padding="5dp"
android:background="@drawable/selector_white_gray"
android:layout_height="50dp"
android:layout_weight="1.0"
android:onClick="SearchButtonProcess"
android:text="公交" />
<Button
android:id="@+id/button_drive_routePlan"
android:layout_width="0dp"
android:drawableLeft="@drawable/ic_drive"
android:layout_height="50dp"
android:layout_weight="1.0"
android:padding="5dp"
android:background="@drawable/selector_white_gray"
android:onClick="SearchButtonProcess"
android:text="驾车" />
<Button
android:id="@+id/button_walk_routePlan"
android:layout_width="0dp"
android:layout_height="50dp"
android:drawableLeft="@drawable/ic_walk"
android:layout_weight="1.0"
android:padding="5dp"
android:background="@drawable/selector_white_gray"
android:onClick="SearchButtonProcess"
android:text="步行" />
</LinearLayout>
<LinearLayout
android:id="@+id/linearLayout_node_routePlan"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_marginBottom="10dip"
android:visibility="gone"
android:gravity="bottom|center_horizontal" >
<Button
android:id="@+id/button_pre_routePlan"
android:layout_width="60dp"
android:layout_height="30dp"
android:layout_marginRight="2dip"
android:background="@drawable/pre_"
android:onClick="nodeClick" />
<Button
android:id="@+id/button_next_routePlan"
android:layout_width="60dp"
android:layout_height="30dp"
android:layout_marginLeft="2dip"
android:background="@drawable/next_"
android:onClick="nodeClick" />
</LinearLayout>
</FrameLayout>
posted @
2015-07-08 23:57 Terry Zou|
编辑 收藏<LinearLayout
android:id="@+id/estate_linear"
android:layout_width="fill_parent"
android:layout_height="35dp"
android:layout_weight="1"
android:background="@drawable/border_rounded_gray_white"
android:layout_gravity="center_vertical"
android:gravity="center_vertical"
android:layout_margin="5dp"
android:orientation="horizontal" >
<ImageButton
android:id="@+id/object_btn_search"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="8dp"
android:layout_gravity="center_vertical|right"
android:background="@drawable/btn_search"
android:contentDescription="@null"
android:scaleType="fitXY" />
<RelativeLayout
android:layout_width="1dp"
android:layout_height="33dp"
android:layout_marginLeft="8dp"
android:background="@color/color_line" />
<EditText
android:id="@+id/object_et_content"
style="@style/StringSearchText"
android:layout_gravity="left|center_vertical"
android:layout_marginLeft="2dp"
android:layout_marginRight="8dp"
android:layout_weight="1"
android:background="@null"
android:hint="@string/tip_search_hint"
android:imeOptions="actionSend"
android:singleLine="true"
android:textCursorDrawable="@null"
android:textColorHint="#626463" />
<ImageButton
android:id="@+id/object_btn_del"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="right|center_vertical"
android:layout_marginRight="10dp"
android:background="@drawable/ic_clear" />
</LinearLayout>
border_rounded_gray_white.xml
<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >
<!-- 连框颜色值 -->
<item>
<shape>
<solid android:color="@color/bg_gray" />
<corners
android:bottomLeftRadius="3dp"
android:bottomRightRadius="3dp"
android:topLeftRadius="3dp"
android:topRightRadius="3dp" />
</shape>
</item>
<!-- 主体背景颜色值 -->
<item
android:bottom="1dp"
android:left="1dp"
android:right="1dp"
android:top="1dp">
<shape>
<solid android:color="@color/white" />
<corners
android:bottomLeftRadius="3dp"
android:bottomRightRadius="3dp"
android:topLeftRadius="3dp"
android:topRightRadius="3dp" />
</shape>
</item>
</layer-list>
<style name="StringSearchText">
<item name="android:textSize">14dp</item>
<item name="android:layout_width">wrap_content</item>
<item name="android:layout_height">wrap_content</item>
<item name="android:textColor">@android:color/black</item>
</style>
btn_search.xml
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<!-- 没有焦点时的背景图片 -->
<item android:drawable="@drawable/ic_search_normal" android:state_window_focused="false"/>
<!-- 非触摸模式下获得焦点并单击时的背景图片 -->
<item android:drawable="@drawable/ic_search_pressed" android:state_focused="true" android:state_pressed="true"/>
<!-- 触摸模式下单击时的背景图片 -->
<item android:drawable="@drawable/ic_search_pressed" android:state_focused="false" android:state_pressed="true"/>
<!-- 选中时的图片背景 -->
<item android:drawable="@drawable/ic_search_pressed" android:state_selected="true"/>
<!-- 获得焦点时的图片背景 -->
<item android:drawable="@drawable/ic_search_pressed" android:state_focused="true"/>
<!-- 默认图片背景 -->
<item android:drawable="@drawable/ic_search_normal"/>
</selector>
<color name="color_line">#bebebe</color>
private TextWatcher textWatcher = new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count,
int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before,
int count) {
}
@Override
public void afterTextChanged(Editable s) {
mKeywords = tv_keyword.getText().toString();
AgUtils.log(TAG+"mKeywords:"+mKeywords, 4);
if (TextUtils.isEmpty(mKeywords)) {
object_btn_del.setVisibility(View.GONE);
} else {
object_btn_del.setVisibility(View.VISIBLE);
searchIndexListInfo();
}
}
};
tv_keyword.addTextChangedListener(textWatcher);
posted @
2015-07-08 23:55 Terry Zou|
编辑 收藏转载：http://www.cnblogs.com/allenzheng/archive/2013/04/28/3050065.html
当应用运行起来后就会开启一条线程，线程中会运行一个任务栈，当Activity实例创建后就会放入任务栈中。Activity启动模式的设置在AndroidManifest.xml文件中，通过配置Activity的属性android:launchMode=""设置。
1. Standared模式（默认）
我们平时直接创建的Activity都是这种模式的Activity，这种模式的Activity的特点是：只要你创建了Activity实例，一旦激活该Activity，则会向任务栈中加入新创建的实例，退出Activity则会在任务栈中销毁该实例。
2. SingleTop模式
这种模式会考虑当前要激活的Activity实例在任务栈中是否正处于栈顶，如果处于栈顶则无需重新创建新的实例，会重用已存在的实例，否则会在任务栈中创建新的实例。
3. SingleTask模式
如果任务栈中存在该模式的Activity实例，则把栈中该实例以上的Activity实例全部移除，调用该实例的newInstance()方法重用该Activity，使该实例处於栈顶位置，否则就重新创建一个新的Activity实例。
4. SingleInstance模式
当该模式Activity实例在任务栈中创建后，只要该实例还在任务栈中，即只要激活的是该类型的Activity，都会通过调用实例的newInstance()方法重用该Activity，此时使用的都是同一个Activity实例，它都会处于任务栈的栈顶。此模式一般用于加载较慢的，比较耗性能且不需要每次都重新创建的Activity。
posted @
2015-06-24 18:10 Terry Zou 阅读(462) |
评论 (0) |
编辑 收藏
摘要: android中跨进程通讯的4种方式
转自：http://www.cnblogs.com/sevenyuan/archive/2013/03/22/2975122.html由于android系统中应用程序之间不能共享内存。因此，在不同应用程序之间交互数据（跨进程通讯）就稍微麻烦一些。在android SDK中提供了4种用于跨进程通讯的方式。这4种方式正好对应于android系统中4种应用...
阅读全文
posted @
2015-06-24 17:28 Terry Zou 阅读(493) |
评论 (0) |
编辑 收藏Android 手机上的应用一般情况下都在一个进程中运行。
但是，也可以指定Activity或者Service在Remote 进程中执行。多数情况下，只有在用户认为应用退出后还需要继续后台长期运行的应用，才需要这样做。此时，该应用有两个进程。
还有一种hack的方式，在apk中通过调用命令行来启动另外的进程。此种方式用户不可见，也不安全。不提倡。
posted @
2015-06-24 17:12 Terry Zou 阅读(537) |
评论 (0) |
编辑 收藏官网帮助文档链接：
http://developer.android.com/guide/components/fragments.html
主要看两张图，和跑代码
一，Fragment的生命周
二，与Activity生命周期的对比
场景演示 : 切换到该Fragment
11-29 14:26:35.095: D/AppListFragment(7649): onAttach
11-29 14:26:35.095: D/AppListFragment(7649): onCreate
11-29 14:26:35.095: D/AppListFragment(7649): onCreateView
11-29 14:26:35.100: D/AppListFragment(7649): onActivityCreated
11-29 14:26:35.120: D/AppListFragment(7649): onStart
11-29 14:26:35.120: D/AppListFragment(7649): onResume
屏幕灭掉：
11-29 14:27:35.185: D/AppListFragment(7649): onPause
11-29 14:27:35.205: D/AppListFragment(7649): onSaveInstanceState
11-29 14:27:35.205: D/AppListFragment(7649): onStop
屏幕解锁
11-29 14:33:13.240: D/AppListFragment(7649): onStart
11-29 14:33:13.275: D/AppListFragment(7649): onResume
切换到其他Fragment:
11-29 14:33:33.655: D/AppListFragment(7649): onPause
11-29 14:33:33.655: D/AppListFragment(7649): onStop
11-29 14:33:33.660: D/AppListFragment(7649): onDestroyView
切换回本身的Fragment:
11-29 14:33:55.820: D/AppListFragment(7649): onCreateView
11-29 14:33:55.825: D/AppListFragment(7649): onActivityCreated
11-29 14:33:55.825: D/AppListFragment(7649): onStart
11-29 14:33:55.825: D/AppListFragment(7649): onResume
回到桌面
11-29 14:34:26.590: D/AppListFragment(7649): onPause
11-29 14:34:26.880: D/AppListFragment(7649): onSaveInstanceState
11-29 14:34:26.880: D/AppListFragment(7649): onStop
回到应用
11-29 14:36:51.940: D/AppListFragment(7649): onStart
11-29 14:36:51.940: D/AppListFragment(7649): onResume
退出应用
11-29 14:37:03.020: D/AppListFragment(7649): onPause
11-29 14:37:03.155: D/AppListFragment(7649): onStop
11-29 14:37:03.155: D/AppListFragment(7649): onDestroyView
11-29 14:37:03.165: D/AppListFragment(7649): onDestroy
11-29 14:37:03.165: D/AppListFragment(7649): onDetach
比Activity多了一些生命周期，完整和Activity对接上，大家好好利用。
转载：http://blog.csdn.net/forever_crying/article/details/8238863/
posted @
2015-06-24 16:05 Terry Zou 阅读(431) |
评论 (0) |
编辑 收藏ANR(Application Not Responding)
ANR定义：在Android上，如果你的应用程序有一段时间响应不够灵敏，系统会向用户显示一个对话框，这个对话框称作应用程序无响应对话框（ANR：Application Not Responding），用户可以选择“等待”让应用程序继续运行，也可以选择“强制关闭”。所以一个顺畅合理的应用程序不会出现ANR，而让用户处理这个对话框。因此，在程序里对响应性能的设计很重要，这样系统不会显示ANR给用户。
默认情况下，Android的Activity执行时间为5s,BroadcastReceiver的最长执行时间为10s.
第一，什么会引发ANR
在Android里，应用程序响应由Activity Manager和WindowManager系统服务监视的，当它监听到一下一种情况时，Android就会针对特定的应用程序显示ANR：
1).在5秒内没有响应输入事件（例如，按键按下，屏幕触摸）
2).BroadcastReceiver在10秒内没有执行完毕
造成以上两点多原因有很多，比如在主线程中做非常耗时的操作，比如下载，IO异常等。
潜在的耗时操作，例如网络或数据库操作或者高耗时的计算如改变位图尺寸，这些操作应该放在子线程中（或者以数据库为例，通过异步请求的方式）来完成，然而，不是说你的主线程阻塞在那里等待子线程来完成--也不用调用Thread.wait()或Thread.sleep();替代的方法是主线程需要为子线程提供一个handler，以便完成时能够交给主线程，以这种方式设计你的应用程序，将能保证你的主线程保持对输入的响应性并能避免由于5秒输入事件的超时引发的ANR对话框。
第二，如何避免ANR
1.运行在主线程里的任何方法都尽可能少做事情。特别是，Activity应该在它的关键生命周期方法（如onCreate()和onResume()）里尽可能少的去做创建操作。（可以采用重新开启子线程的方式，然后使用Handler+Message的方式做一些操作，比如更新主线程中的ui等）
2.应用程序应该避免在BroadcastReceiver里做耗时的操作或计算。但不再是在子线程里做这些任务（因为 BroadcastReceiver的生命周期短），替代的是，如果响应Intent广播需要执行一个耗时的动作的话，应用程序应该启动一个 Service。（此处需要注意的是可以在广播接受者中启动Service，但是却不可以在Service中启动broadcasereciver,关于原因后续会有介绍，此处不是本文重点）
3.避免在Intent Receiver里启动一个Activity，因为它会创建一个新的画面，并从当前用户正在运行的程序上抢夺焦点。如果你的应用程序在响应Intent广 播时需要向用户展示什么，你应该使用Notification Manager来实现。
总结：anr异常也是在程序中自己经常遇到的问题，主要的解决办法自己最常用的就是不要在主线程中做耗时的操作，而应放在子线程中来实现，比如采用Handler+mesage的方式，或者是有时候需要做一些和网络相互交互的耗时操作就采用asyntask异步任务的方式（它的底层其实Handler+mesage有所区别的是它是线程池）等，在主线程中更新UI。
posted @
2015-06-24 16:00 Terry Zou 阅读(295) |
评论 (0) |
编辑 收藏
摘要: String string="
欢迎你来到的
jack
的
android
使用技术总结
";
TextV
iew info2=(TextView)super.findV
iewById(R.id.info); ...
阅读全文
posted @
2015-06-15 14:21 Terry Zou 阅读(218) |
评论 (0) |
编辑 收藏
摘要: 开发自定义控件的步骤:
1、了解View的工作原理
2、 编写继承自View的子类
3、 为自定义View类增加属性
4、 绘制控件
5、 响应用户消息
6 、自定义回调函数
一、View结构原理
Android系统的视图结构的设计也采用了组合模式，即View作为所有图形的基类，Viewgroup对View继承...
阅读全文
posted @
2015-05-19 17:29 Terry Zou 阅读(364) |
评论 (0) |
编辑 收藏
摘要: Android 管理Fragments
FragmentManager
为了管理Activity中的fragments，需要使...
阅读全文
posted @
2015-05-18 18:28 Terry Zou 阅读(399) |
评论 (0) |
编辑 收藏|
java.version |
Java 运行时环境版本 |
|
java.vendor |
Java 运行时环境供应商 |
|
java.vendor.url |
Java 供应商的 URL |
|
java.home |
Java 安装目录 |
|
java.vm.specification.version |
Java 虚拟机规范版本 |
|
java.vm.specification.vendor |
Java 虚拟机规范供应商 |
|
java.vm.specification.name |
Java 虚拟机规范名称 |
|
java.vm.version |
Java 虚拟机实现版本 |
|
java.vm.vendor |
Java 虚拟机实现供应商 |
|
java.vm.name |
Java 虚拟机实现名称 |
|
java.specification.version |
Java 运行时环境规范版本 |
|
java.specification.vendor |
Java 运行时环境规范供应商 |
|
java.specification.name |
Java 运行时环境规范名称 |
|
java.class.version |
Java 类格式版本号 |
|
java.class.path |
Java 类路径 |
|
java.library.path |
加载库时搜索的路径列表 |
|
java.io.tmpdir |
默认的临时文件路径 |
|
java.compiler |
要使用的 JIT 编译器的名称 |
|
java.ext.dirs |
一个或多个扩展目录的路径 |
|
os.name |
操作系统的名称 |
|
os.arch |
操作系统的架构 |
|
os.version |
操作系统的版本 |
|
file.separator |
文件分隔符（在 UNIX 系统中是“/”） |
|
path.separator |
路径分隔符（在 UNIX 系统中是“:”） |
|
line.separator |
行分隔符（在 UNIX 系统中是“/n”） |
|
user.name |
用户的账户名称 |
|
user.home |
用户的主目录 |
|
user.dir |
用户的当前工作目录 |
StringBuffer response = new StringBuffer();while ((line = reader.readLine()) != null) { response.append(line).append( System.getProperty("line.separator"));}
public class SystemProperty {
public static void main(String args[]) {
System.out.println("java_vendor:" + System.getProperty("java.vendor"));
System.out.println("java_vendor_url:"
+ System.getProperty("java.vendor.url"));
System.out.println("java_home:" + System.getProperty("java.home"));
System.out.println("java_class_version:"
+ System.getProperty("java.class.version"));
System.out.println("java_class_path:"
+ System.getProperty("java.class.path"));
System.out.println("os_name:" + System.getProperty("os.name"));
System.out.println("os_arch:" + System.getProperty("os.arch"));
System.out.println("os_version:" + System.getProperty("os.version"));
System.out.println("user_name:" + System.getProperty("user.name"));
System.out.println("user_home:" + System.getProperty("user.home"));
System.out.println("user_dir:" + System.getProperty("user.dir"));
System.out.println("java_vm_specification_version:"
+ System.getProperty("java.vm.specification.version"));
System.out.println("java_vm_specification_vendor:"
+ System.getProperty("java.vm.specification.vendor"));
System.out.println("java_vm_specification_name:"
+ System.getProperty("java.vm.specification.name"));
System.out.println("java_vm_version:"
+ System.getProperty("java.vm.version"));
System.out.println("java_vm_vendor:"
+ System.getProperty("java.vm.vendor"));
System.out
.println("java_vm_name:" + System.getProperty("java.vm.name"));
System.out.println("java_ext_dirs:"
+ System.getProperty("java.ext.dirs"));
System.out.println("file_separator:"
+ System.getProperty("file.separator"));
System.out.println("path_separator:"
+ System.getProperty("path.separator"));
System.out.println("line_separator:"
+ System.getProperty("line.separator"));
}
转载：http://blog.csdn.net/kongqz/article/details/3987198
posted @
2015-05-15 09:33 Terry Zou 阅读(395) |
评论 (0) |
编辑 收藏
注意上面的双引号，何为“容易”？言下之意就是该activity还没有被销毁，而仅仅是一种可能性。这种可能性有哪些？通过重写一个activity的所有生命周期的onXXX方法，包括onSaveInstanceState和onRestoreInstanceState方法，我们可以清楚地知道当某个activity（假定为activity A）显示在当前task的最上层时，其onSaveInstanceState方法会在什么时候被执行，有这么几种情况：
1、当用户按下HOME键时。
这是显而易见的，系统不知道你按下HOME后要运行多少其他的程序，自然也不知道activity A是否会被销毁，故系统会调用onSaveInstanceState，让用户有机会保存某些非永久性的数据。以下几种情况的分析都遵循该原则
2、长按HOME键，选择运行其他的程序时。
3、按下电源按键（关闭屏幕显示）时。
4、从activity A中启动一个新的activity时。
5、屏幕方向切换时，例如从竖屏切换到横屏时。
在屏幕切换之前，系统会销毁activity A，在屏幕切换之后系统又会自动地创建activity A，所以onSaveInstanceState一定会被执行。
总而言之，onSaveInstanceState的调用遵循一个重要原则，即当系统“未经你许可”时销毁了你的activity，则onSaveInstanceState会被系统调用，这是系统的责任，因为它必须要提供一个机会让你保存你的数据（当然你不保存那就随便你了）。
至于onRestoreInstanceState方法，需要注意的是，onSaveInstanceState方法和onRestoreInstanceState方法“不一定”是成对的被调用的，onRestoreInstanceState被调用的前提是，activity A“确实”被系统销毁了，而如果仅仅是停留在有这种可能性的情况下，则该方法不会被调用，例如，当正在显示activity A的时候，用户按下HOME键回到主界面，然后用户紧接着又返回到activity A，这种情况下activity A一般不会因为内存的原因被系统销毁，故activity A的onRestoreInstanceState方法不会被执行。
另外，onRestoreInstanceState的bundle参数也会传递到onCreate方法中，你也可以选择在onCreate方法中做数据还原。 转载：http://gundumw100.iteye.com/blog/1115080
posted @
2015-05-11 10:34 Terry Zou 阅读(337) |
评论 (0) |
编辑 收藏Android中常常使用shape来定义控件的一些显示属性，今天看了一些shape的使用，对shape有了大体的了解，稍作总结：
先看下面的代码：
<shape>
<!-- 实心 -->
<solid android:color="#ff9d77"/>
<!-- 渐变 -->
<gradient
android:startColor="#ff8c00"
android:endColor="#FFFFFF"
android:angle="270" />
<!-- 描边 -->
<stroke
android:width="2dp"
android:color="#dcdcdc" />
<!-- 圆角 -->
<corners
android:radius="2dp" />
<padding
android:left="10dp"
android:top="10dp"
android:right="10dp"
android:bottom="10dp" />
</shape>
solid：实心，就是填充的意思
android:color指定填充的颜色
gradient：渐变
android:startColor和android:endColor分别为起始和结束颜色，ndroid:angle是渐变角度，必须为45的整数倍。
另外渐变默认的模式为android:type="linear"，即线性渐变，可以指定渐变为径向渐变，android:type="radial"，径向渐变需要指定半径android:gradientRadius="50"。
stroke：描边
android:width="2dp" 描边的宽度，android:color 描边的颜色。
我们还可以把描边弄成虚线的形式，设置方式为：
android:dashWidth="5dp"
android:dashGap="3dp"
其中android:dashWidth表示'-'这样一个横线的宽度，android:dashGap表示之间隔开的距离。
corners：圆角
android:radius为角的弧度，值越大角越圆。
我们还可以把四个角设定成不同的角度，方法为：
<corners
android:topRightRadius="20dp" 右上角
android:bottomLeftRadius="20dp" 右下角
android:topLeftRadius="1dp" 左上角
android:bottomRightRadius="0dp" 左下角
/>
这里有个地方需要注意，bottomLeftRadius是右下角，而不是左下角，这个有点郁闷，不过不影响使用，记得别搞错了就行。
还有网上看到有人说设置成0dp无效，不过我在测试中发现是可以的，我用的是2.2，可能修复了这个问题吧，如果无效的话那就只能设成1dp了。
padding：间隔
这个就不用多说了，XML布局文件中经常用到。
大体的就是这样，以下是一个使用的具体示例：用在Selector中作为Button的背景，分别定义了按钮的一般状态、获得焦点状态和按下时的状态，具体代码如下：
main.xml:
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="TestShapeButton"
android:background="@drawable/button_selector"
/>
button_selector.xml:
<?xml version="1.0" encoding="utf-8"?>
<selector
xmlns:android="http://schemas.android.com/apk/res/android">
<item android:state_pressed="true" >
<shape>
<!-- 渐变 -->
<gradient
android:startColor="#ff8c00"
android:endColor="#FFFFFF"
android:type="radial"
android:gradientRadius="50" />
<!-- 描边 -->
<stroke
android:width="2dp"
android:color="#dcdcdc"
android:dashWidth="5dp"
android:dashGap="3dp" />
<!-- 圆角 -->
<corners
android:radius="2dp" />
<padding
android:left="10dp"
android:top="10dp"
android:right="10dp"
android:bottom="10dp" />
</shape>
</item>
<item android:state_focused="true" >
<shape>
<gradient
android:startColor="#ffc2b7"
android:endColor="#ffc2b7"
android:angle="270" />
<stroke
android:width="2dp"
android:color="#dcdcdc" />
<corners
android:radius="2dp" />
<padding
android:left="10dp"
android:top="10dp"
android:right="10dp"
android:bottom="10dp" />
</shape>
</item>
<item>
<shape>
<solid android:color="#ff9d77"/>
<stroke
android:width="2dp"
android:color="#fad3cf" />
<corners
android:topRightRadius="5dp"
android:bottomLeftRadius="5dp"
android:topLeftRadius="0dp"
android:bottomRightRadius="0dp"
/>
<padding
android:left="10dp"
android:top="10dp"
android:right="10dp"
android:bottom="10dp" />
</shape>
</item>
</selector>
运行效果如下图：
一般状态：
获得焦点状态：
按下状态：
转载：http://kofi1122.blog.51cto.com/2815761/521605/
posted @
2015-04-18 10:41 Terry Zou 阅读(260) |
评论 (0) |
编辑 收藏
摘要: 所谓自定义控件(或称组件)也就是编写自己的控件类型,而非Android中提供的标准的控件,如TextView,CheckBox等等.不过自定义的控件一般也都是从标准控件继承来的,或者是多种控件组合,或者是对标准控件的属性进行改变而得到的自己满意的控件.
自定义控件可能会有很多种方法,这里只介绍我要介绍的方法.
&nb...
阅读全文
posted @
2015-04-14 10:53 Terry Zou 阅读(322) |
评论 (0) |
编辑 收藏在Android的联机文档中，有对Activity的简单介绍，现在通过编写代码对Activity的启动模式做一个深入的理解。
在配置文件AndroidManifest.xml中，activity元素的android:launchMode属性用来配置对应Activity的启动模式，目前有以下四种启动模式：
1.standard
2.singleTop
3.singleTask
4.singleInstance
如果不对Activity设置启动模式，默认就是standard模式
一、standard
请看以下代码，实现了一个Activity ：
public class A_Activity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView textView=new TextView(this);
textView.setText(this+"");//这里用于打印当前Activity的hashcode，可以此判断Activity实例是不是同一个对象
Button button=new Button(this);
button.setText("Go next activity");
button.setOnClickListener(new OnClickListener(){
public void onClick(View v) {
// TODO Auto-generated method stub
Intent intent=new Intent();
intent.setClass(A_Activity.this, A_Activity.class);//说明发出Intent与启动的Activity都是A_Activity的实例
startActivity(intent);
}
});
LinearLayout layout=new LinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
layout.addView(textView);
layout.addView(button);
setContentView(layout);
}
}
运行之，请看下图：
点击button后，注意看第一行的textView
由此可知，生成了新的A_Activity对象，这时我们按回退键，就会依次回到之前的Activity。点击button的过程就是压栈的过程，在standard模式下，就会不断生成新的Activity对象
二、singleTop
singleTop和standard模式都会将intent发送给新的Activity实例，不同的是，如果创建Intent的时候栈顶有要创建的singleTop模式下的Activity实例，则将Intent发送给该实例，不会再创建Activity的新实例。
还是使用之前的代码，只是设置A_Activity的启动模式为singleTop:android:launchMode="singleTop"，运行之，请看下图：
这个时候我们无论点击多少次button，textView都显示同一个Activity实例，按回退键时会直接退出程序，表明在singleTop模式下，如果在栈顶存在Intent中那个目标Activity的实例，就不会创建新的实例，而直接使用栈顶的对象，对于资源有限的移动设备来说，也是有实际意义的。
如果是在不同Activity之间跳转，就会跟standard模式的情形一样，请看下面代码：
public class A_Activity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView textView=new TextView(this);
textView.setText(this+"");
Button button=new Button(this);
button.setText("Go B_Activity");
button.setOnClickListener(new OnClickListener(){
public void onClick(View v) {
// TODO Auto-generated method stub
Intent intent=new Intent();
intent.setClass(A_Activity.this, B_Activity.class);//从A跳转到B
startActivity(intent);
}
});
LinearLayout layout=new LinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
layout.addView(textView);
layout.addView(button);
setContentView(layout);
}
}
public class B_Activity extends Activity {
/**<li>Description: </li>
*
* @param savedInstanceState
* @see android.app.Activity#onCreate(android.os.Bundle)
*/
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
TextView textView=new TextView(this);
textView.setText(this+"");
Button button=new Button(this);
button.setText("Go A_Activity");
button.setOnClickListener(new OnClickListener(){
public void onClick(View v) {
// TODO Auto-generated method stub
Intent intent=new Intent();
intent.setClass(B_Activity.this, A_Activity.class);//从B跳转到A
startActivity(intent);
}
});
LinearLayout layout=new LinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
layout.addView(textView);
layout.addView(button);
setContentView(layout);
}
}
运行后，如下图：
点击button后：
再点击button后：
这样每次都会创建目标Activity的新实例，因为在跳转时，处于栈顶的对象不是目标Activity的实例
三、singleTask
singleTask模式只能创建一个实例，当发送一个Intent，目标Activity为singleTask模式时，系统会检查栈里面是否已经有该Activity的实例，如果有就直接将Intent发送给它，还是使用（二）中的代码，将A_Activity启动模式设置为singleTask，B_Activity启动模式设置为standard，启动后如下图：
点击button后：
继续点击button:
由此可知，singleTask模式的A_Activity在栈中只有一个实例，可以被重复使用
并且，如果收到Intent生成一个新实例，那么用户可以通过回退键回到上一个状态，如果是已经存在的一个activity来处理这个Intent的话，就无法通过回退键回到上一个状态（对singleInstance同样适用） ，比如刚才最后一步如果再按回退键，就会直接退出程序，而不会回到上一步的状态。
四、singleInstance
这个模式下的Activity在一个单独的task栈中，这个栈也只能包含一个Activity的实例，将上面代码稍微改动一下，显示taskId:
A_Activity 中：textView.setText(this.getTaskId()+"");
B_Activity 中：textView.setText(this.getTaskId()+"");
另外将B_Activity 设置为singleInstance模式，A_Activity 设置为standard模式，启动后：
点击button后：
表明启动了新的task
总结四个模式的不同：
1、Intent的目标Activity由哪个task持有
standard与singleTop的Activity所在task，与收到的Intent的发送者所在task相同，除非Intent包括参数FLAG_ACTIVITY_NEW_TASK，该参数会启动Activity到新的task中；singleTask和singleInstance总是把Activity作为一个task的根元素，它们不会被启动到其他task里
2、是否允许Activity的多个实例
standard与singleTop可以被实例化多次，可以存在不同task中，并且一个task可以包括同一activity的多个实例
singleTask与singleInstance则在同一个task中只能允许Activity的一个实例，并且是task的根元素
3、在同一个task栈中，是否允许其他Activity的实例存在
singleInstance单独在一个task中，其他启动模式允许不同Activity的实例存在
4、是否每次生成新实例接收Intent
standard每次启动都会生成新实例
singleTop的activity如果在task的栈顶的话，则不生成新的activity实例，直接使用该实例，否则，就要生成新的实例
singleInstance在所在栈中是唯一的activity，它每次都会被重用
singleTask如果task栈中有该模式的Activity，就不生成新的activity实例，直接使用该实例，否则，就要生成新的实例
转载：http://blog.csdn.net/leiswpu/article/details/6248528
posted @
2015-04-13 17:56 Terry Zou 阅读(310) |
评论 (0) |
编辑 收藏1. reference：参考某一资源ID。
（1）属性定义：
<declare-styleable name = "名称">
<attr name = "background" format = "reference" />
</declare-styleable>
（2）属性使用：
<ImageView
android:layout_width = "42dip"
android:layout_height = "42dip"
android:background = "@drawable/图片ID"
/>
2. color：颜色值。
（1）属性定义：
<declare-styleable name = "名称">
<attr name = "textColor" format = "color" />
</declare-styleable>
（2）属性使用：
<TextView
android:layout_width = "42dip"
android:layout_height = "42dip"
android:textColor = "#00FF00"
/>
3. boolean：布尔值。
（1）属性定义：
<declare-styleable name = "名称">
<attr name = "focusable" format = "boolean" />
</declare-styleable>
（2）属性使用：
<Button
android:layout_width = "42dip"
android:layout_height = "42dip"
android:focusable = "true"
/>
4. dimension：尺寸值。
（1）属性定义：
<declare-styleable name = "名称">
<attr name = "layout_width" format = "dimension" />
</declare-styleable>
（2）属性使用：
<Button
android:layout_width = "42dip"
android:layout_height = "42dip"
/>
5. float：浮点值。
（1）属性定义：
<declare-styleable name = "AlphaAnimation">
<attr name = "fromAlpha" format = "float" />
<attr name = "toAlpha" format = "float" />
</declare-styleable>
（2）属性使用：
<alpha
android:fromAlpha = "1.0"
android:toAlpha = "0.7"
/>
6. integer：整型值。
（1）属性定义：
<declare-styleable name = "AnimatedRotateDrawable">
<attr name = "visible" />
<attr name = "frameDuration" format="integer" />
<attr name = "framesCount" format="integer" />
<attr name = "pivotX" />
<attr name = "pivotY" />
<attr name = "drawable" />
</declare-styleable>
（2）属性使用：
<animated-rotate
xmlns:android = "http://schemas.android.com/apk/res/android"
android:drawable = "@drawable/图片ID"
android:pivotX = "50%"
android:pivotY = "50%"
android:framesCount = "12"
android:frameDuration = "100"
/>
7. string：字符串。
（1）属性定义：
<declare-styleable name = "MapView">
<attr name = "apiKey" format = "string" />
</declare-styleable>
（2）属性使用：
<com.google.android.maps.MapView
android:layout_width = "fill_parent"
android:layout_height = "fill_parent"
android:apiKey = "0jOkQ80oD1JL9C6HAja99uGXCRiS2CGjKO_bc_g"
/>
8. fraction：百分数。
（1）属性定义：
<declare-styleable name="RotateDrawable">
<attr name = "visible" />
<attr name = "fromDegrees" format = "float" />
<attr name = "toDegrees" format = "float" />
<attr name = "pivotX" format = "fraction" />
<attr name = "pivotY" format = "fraction" />
<attr name = "drawable" />
</declare-styleable>
（2）属性使用：
<rotate
xmlns:android = "http://schemas.android.com/apk/res/android"
android:interpolator = "@anim/动画ID"
android:fromDegrees = "0"
android:toDegrees = "360"
android:pivotX = "200%"
android:pivotY = "300%"
android:duration = "5000"
android:repeatMode = "restart"
android:repeatCount = "infinite"
/>
9. enum：枚举值。
（1）属性定义：
<declare-styleable name="名称">
<attr name="orientation">
<enum name="horizontal" value="0" />
<enum name="vertical" value="1" />
</attr>
</declare-styleable>
（2）属性使用：
<LinearLayout
xmlns:android = "http://schemas.android.com/apk/res/android"
android:orientation = "vertical"
android:layout_width = "fill_parent"
android:layout_height = "fill_parent"
>
</LinearLayout>
10. flag：位或运算。
（1）属性定义：
<declare-styleable name="名称">
<attr name="windowSoftInputMode">
<flag name = "stateUnspecified" value = "0" />
<flag name = "stateUnchanged" value = "1" />
<flag name = "stateHidden" value = "2" />
<flag name = "stateAlwaysHidden" value = "3" />
<flag name = "stateVisible" value = "4" />
<flag name = "stateAlwaysVisible" value = "5" />
<flag name = "adjustUnspecified" value = "0x00" />
<flag name = "adjustResize" value = "0x10" />
<flag name = "adjustPan" value = "0x20" />
<flag name = "adjustNothing" value = "0x30" />
</attr>
</declare-styleable>
（2）属性使用：
<activity
android:name = ".StyleAndThemeActivity"
android:label = "@string/app_name"
android:windowSoftInputMode = "stateUnspecified | stateUnchanged | stateHidden">
<intent-filter>
<action android:name = "android.intent.action.MAIN" />
<category android:name = "android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
注意：
属性定义时可以指定多种类型值。
（1）属性定义：
<declare-styleable name = "名称">
<attr name = "background" format = "reference|color" />
</declare-styleable>
（2）属性使用：
<ImageView
android:layout_width = "42dip"
android:layout_height = "42dip"
android:background = "@drawable/图片ID|#00FF00"
/>
posted @
2015-03-23 22:43 Terry Zou 阅读(157) |
评论 (0) |
编辑 收藏
摘要: showDialog()调用createDialog()和onPrepareDialog()，其中createDialog()调用onCreateDialog()。例子如下所示
Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> ...
阅读全文
posted @
2015-02-03 08:55 Terry Zou 阅读(295) |
评论 (0) |
编辑 收藏private Vibrator vibrator;
取得震动服务的句柄
vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);
或者 vibrator = (Vibrator)getApplication().getSystemService(Service.VIBRATOR_SERVICE);
开始震动有两个接口
1 . vibrator.vibrate(2000);//震动指定时间 ，数据类型long，单位为毫秒，一毫秒为1/1000秒
2. vibrator.vibrate(new long[]{100,10,100,1000}, -1);//按照指定的模式去震动。
数组参数意义：第一个参数为等待指定时间后开始震动，震动时间为第二个参数。后边的参数依次为等待震动和震动的时间
第二个参数为重复次数，-1为不重复，0为一直震动
取消震动
vibrator.cancel();//取消震动，立即停止震动
震动为一直震动的话，如果不取消震动，就算退出，也会一直震动
最重要的，增加权限，否则运行时出错
<uses-permission android:name="android.permission.VIBRATE"/>
posted @
2015-01-28 17:18 Terry Zou 阅读(734) |
评论 (0) |
编辑 收藏java多线程用法-使用AtomicInteger
下面通过简单的两个例子的对比来看一下 AtomicInteger 的强大的功能
class Counter {
private volatile int count = 0;
public synchronized void increment() {
count++; //若要线程安全执行执行count++，需要加锁
}
public int getCount() {
return count;
}
}
class Counter {
private AtomicInteger count = new AtomicInteger();
public void increment() {
count.incrementAndGet();
}
//使用AtomicInteger之后，不需要加锁，也可以实现线程安全。
public int getCount() {
return count.get();
}
}
从上面的例子中我们可以看出：使用AtomicInteger是非常的安全的
那么为什么不使用记数器自加呢，例如count++这样的，因为这种计数是线程不安全的，高并发访问时统计会有误，而AtomicInteger为什么能够达到多而不乱，处理高并发应付自如呢？
这是由硬件提供原子操作指令实现的。在非激烈竞争的情况下，开销更小，速度更快。Java.util.concurrent中实现的原子操作类包括：
AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference。
posted @
2015-01-28 16:50 Terry Zou 阅读(150) |
评论 (0) |
编辑 收藏
01-21 20:58:10.615: E/HwLauncher(3286): Launcher dialog dismiss failed : java.lang.IllegalArgumentException: no dialog with id 1 was ever shown via Activity#showDialog
01-21 20:58:10.715: E/SubmitMessage(8010): Submit string: submit:trigger=0,bugtype=2,modulename=com.zhihe.xqsh,level=1,testtype=NORMAL,path=/data/log/unzip/H60-L01_V100R001CHNC00B307_DU2SSE1472000007_20150121205810_crash
01-21 20:58:10.940: E/HwSystemManager(3431): HoldService:mAppInfo == null
01-21 20:58:10.960: E/HwSystemManager(3431): HoldService:mAppInfo == null
01-21 20:58:12.745: E/HwLauncher(3286): Launcher dialog dismiss failed : java.lang.IllegalArgumentException: no dialog with id 1 was ever shown via Activity#showDialog
01-21 20:58:15.230: E/Thermal-daemon(2421): [ap] temp_new :35 temp_old :34
01-21 20:58:20.230: E/Thermal-daemon(2421): [ap] temp_new :34 temp_old :35
01-21 20:58:20.235: E/Thermal-daemon(2421): Report temperature: [ap] temp :34 report_threshold:1
当用到FinalBitmap时，及对图片进行异步缓存的情况下，第三方包可能用到了存储卡
posted @
2015-01-22 11:21 Terry Zou 阅读(2587) |
评论 (0) |
编辑 收藏标签用于指定屏幕内的焦点View。
例如我们点击tab键或enter键焦点自动进入下一个输入框
用法: 将标签置于Views标签内部
<EditText id="@+id/text"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="0"
android:paddingBottom="4">
<requestFocus />
</EditText>
posted @
2015-01-20 15:32 Terry Zou 阅读(170) |
评论 (0) |
编辑 收藏- onFinishInflate() 当View中所有的子控件均被映射成xml后触发
- onMeasure( int , int ) 确定所有子元素的大小
- onLayout( boolean , int , int , int , int ) 当View分配所有的子元素的大小和位置时触发
- onSizeChanged( int , int , int , int ) 当view的大小发生变化时触发
- onDraw(Canvas) view渲染内容的细节
- onKeyDown( int , KeyEvent) 有按键按下后触发
- onKeyUp( int , KeyEvent) 有按键按下后弹起时触发
- onTrackballEvent(MotionEvent) 轨迹球事件
- onTouchEvent(MotionEvent) 触屏事件
- onFocusChanged( boolean , int , Rect) 当View获取或失去焦点时触发
- onWindowFocusChanged( boolean ) 当窗口包含的view获取或失去焦点时触发
- onAttachedToWindow() 当view被附着到一个窗口时触发
- onDetachedFromWindow() 当view离开附着的窗口时触发，Android123提示该方法和 onAttachedToWindow() 是相反的。
- onWindowVisibilityChanged( int ) 当窗口中包含的可见的view发生变化时触发
posted @
2014-12-01 22:41 Terry Zou 阅读(765) |
评论 (0) |
编辑 收藏标签用于指定屏幕内的焦点View。
例如我们点击tab键或enter键焦点自动进入下一个输入框
用法: 将标签置于Views标签内部
<EditText id="@+id/text"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="0"
android:paddingBottom="4">
<requestFocus />
</EditText>
android:ems = "10" 设置TextView或者Edittext的宽度为10个字符的宽度。当设置该属性后，控件显示的长度就为10个字符的长度，超出的部分将不显示。
转载：http://blog.sina.com.cn/s/blog_90cdca4c01011kdc.html
posted @
2014-11-27 00:11 Terry Zou 阅读(239) |
评论 (0) |
编辑 收藏java.lang.NullPointerException
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.AbsListView.obtainView(AbsListView.java:2298)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.ListView.measureHeightOfChildren(ListView.java:1263)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.ListView.onMeasure(ListView.java:1175)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureChildBeforeLayout(LinearLayout.java:1404)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureVertical(LinearLayout.java:695)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.onMeasure(LinearLayout.java:588)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.FrameLayout.onMeasure(FrameLayout.java:310)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureChildBeforeLayout(LinearLayout.java:1404)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureVertical(LinearLayout.java:695)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.onMeasure(LinearLayout.java:588)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureChildBeforeLayout(LinearLayout.java:1404)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureVertical(LinearLayout.java:695)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.onMeasure(LinearLayout.java:588)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.FrameLayout.onMeasure(FrameLayout.java:310)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureChildBeforeLayout(LinearLayout.java:1404)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureVertical(LinearLayout.java:695)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.onMeasure(LinearLayout.java:588)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.FrameLayout.onMeasure(FrameLayout.java:310)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.FrameLayout.onMeasure(FrameLayout.java:310)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureChildBeforeLayout(LinearLayout.java:1404)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.measureVertical(LinearLayout.java:695)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.LinearLayout.onMeasure(LinearLayout.java:588)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewGroup.measureChildWithMargins(ViewGroup.java:5169)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.widget.FrameLayout.onMeasure(FrameLayout.java:310)
11-26 10:05:25.363: E/AndroidRuntime(28212): at com.android.internal.policy.impl.PhoneWindow$DecorView.onMeasure(PhoneWindow.java:2310)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.View.measure(View.java:16515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewRootImpl.performMeasure(ViewRootImpl.java:1958)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewRootImpl.measureHierarchy(ViewRootImpl.java:1155)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewRootImpl.performTraversals(ViewRootImpl.java:1337)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewRootImpl.doTraversal(ViewRootImpl.java:1042)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.ViewRootImpl$TraversalRunnable.run(ViewRootImpl.java:5721)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.Choreographer$CallbackRecord.run(Choreographer.java:761)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.Choreographer.doCallbacks(Choreographer.java:574)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.Choreographer.doFrame(Choreographer.java:544)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.view.Choreographer$FrameDisplayEventReceiver.run(Choreographer.java:747)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.os.Handler.handleCallback(Handler.java:733)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.os.Handler.dispatchMessage(Handler.java:95)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.os.Looper.loop(Looper.java:136)
11-26 10:05:25.363: E/AndroidRuntime(28212): at android.app.ActivityThread.main(ActivityThread.java:5050)
11-26 10:05:25.363: E/AndroidRuntime(28212): at java.lang.reflect.Method.invokeNative(Native Method)
11-26 10:05:25.363: E/AndroidRuntime(28212): at java.lang.reflect.Method.invoke(Method.java:515)
11-26 10:05:25.363: E/AndroidRuntime(28212): at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java)
原因是：adapter中返回的时候convertView为null.
posted @
2014-11-26 13:40 Terry Zou 阅读(237) |
评论 (0) |
编辑 收藏Exception:
10-24 17:43:15.112: E/AndroidRuntime(11888): java.lang.IllegalStateException: The specified child already has a parent. You must call removeView() on the child's parent first.
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.view.ViewGroup.addViewInner(ViewGroup.java:3596)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.view.ViewGroup.addView(ViewGroup.java:3449)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.support.v4.view.ViewPager.addView(ViewPager.java:1305)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.view.ViewGroup.addView(ViewGroup.java:3394)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.view.ViewGroup.addView(ViewGroup.java:3370)
10-24 17:43:15.112: E/AndroidRuntime(11888): at com.zhihe.xqsh.adapter.IndexTopPagerAdapter.instantiateItem(IndexTopPagerAdapter.java:72)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.support.v4.view.PagerAdapter.instantiateItem(PagerAdapter.java:110)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.support.v4.view.ViewPager.addNewItem(ViewPager.java:833)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.support.v4.view.ViewPager.populate(ViewPager.java:1017)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.support.v4.view.ViewPager.populate(ViewPager.java:915)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.support.v4.view.ViewPager$3.run(ViewPager.java:245)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.view.Choreographer$CallbackRecord.run(Choreographer.java:761)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.view.Choreographer.doCallbacks(Choreographer.java:574)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.view.Choreographer.doFrame(Choreographer.java:543)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.view.Choreographer$FrameDisplayEventReceiver.run(Choreographer.java:747)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.os.Handler.handleCallback(Handler.java:733)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.os.Handler.dispatchMessage(Handler.java:95)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.os.Looper.loop(Looper.java:136)
10-24 17:43:15.112: E/AndroidRuntime(11888): at android.app.ActivityThread.main(ActivityThread.java:5050)
10-24 17:43:15.112: E/AndroidRuntime(11888): at java.lang.reflect.Method.invokeNative(Native Method)
10-24 17:43:15.112: E/AndroidRuntime(11888): at java.lang.reflect.Method.invoke(Method.java:515)
10-24 17:43:15.112: E/AndroidRuntime(11888): at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:805)
10-24 17:43:15.112: E/AndroidRuntime(11888): at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:621)
10-24 17:43:15.112: E/AndroidRuntime(11888): at dalvik.system.NativeStart.main(Native Method)
10-24 17:43:15.132: I/Process(11888): Sending signal. PID: 11888 SIG: 9
原因：
当图片向左滑动的时候，之后执行instantiateItem方法，而不去执行删除方法，所以出现上述异常
所以在instantiateItem方法中执行删除操作，如下：
View child = mPageViewList.get(position);
if(child.getParent()!=null){
((ViewPager)container).removeView(child);
}
注意，在此执行了删除操作之后，把destroyItem方法中的删除去掉，因为，如果不去掉向左滑动的时候，会显示为空，原因如下：打印url是进行加载View，当加载完成之后会去执行destroyItem中的方法，所以，需要把destroyItem中的删除去掉。
10-24 17:49:14.452: W/(16419): ----zhihe---- IndextoppagerAdapter instantiateItem position:0
10-24 17:49:14.452: W/(16419): ----zhihe---- IndextoppagerAdapter instantiateItem image:http://ys.rili.com.cn/images/image/201401/0111174780.jpg
10-24 17:49:14.462: W/(16419): ----zhihe---- IndextoppagerAdapter destroyItem position:0
posted @
2014-10-24 17:53 Terry Zou 阅读(1324) |
评论 (0) |
编辑 收藏http://blog.csdn.net/asmcvc/article/details/9948419
举例子：
-optimizationpasses 5
-dontusemixedcaseclassnames
-dontskipnonpubliclibraryclasses
-dontpreverify
-verbose
-dontwarn
-dontskipnonpubliclibraryclassmembers
-optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
-libraryjars libs/afinal-0.2.1-bin.jar
-libraryjars libs/armeabi/libBaiduMapSDK_v3_1_0.so #地图相关的C++编译的可执行文件（引擎）不要混淆
-libraryjars libs/armeabi/liblocSDK4d.so #定位相关的C++编译的可执行文件（引擎）不要混淆
-libraryjars libs/afinal-0.2.1-bin.jar
-libraryjars libs/android-support-v4.jar
-libraryjars libs/android-support-v7-recyclerview.jar
-libraryjars libs/apache_httpClient_full_v43.jar
-libraryjars libs/support-annotations-21.0.0-rc1.jar
-libraryjars libs/locSDK_4.2.jar
-libraryjars libs/baidumapapi_v3_1_0.jar
-keep class com.baidu.** { *; }
-keep class vi.com.gdi.bgl.android.**{*;}
-keep public class * extends android.app.Fragment
-keep public class * extends android.app.Activity
-keep public class * extends android.app.Application
-keep public class * extends android.app.Service
-keep public class * extends android.content.BroadcastReceiver
-keep public class * extends android.content.ContentProvider
-keep public class * extends android.app.backup.BackupAgentHelper
-keep public class * extends android.preference.Preference
-keep public class * extends android.support.v4.**
-keep public class com.android.vending.licensing.ILicensingService
-keep class android.support.annotation.** { *; }
-keep class org.apache.http43.** { *; }
-keep class android.support.v7.widget.** { *; }
-keep class net.tsz.afinal.** { *; }
-keep class com.alibaba.fastjson.** { *; }
-keep class android.support.v4.** { *; }
-keepclasseswithmembernames class * {
native <methods>;
}
-keepclasseswithmembers class * {
public <init>(android.content.Context, android.util.AttributeSet);
}
-keepclasseswithmembers class * {
public <init>(android.content.Context, android.util.AttributeSet, int);
}
-keepclassmembers class * extends android.app.Activity {
public void *(android.view.View);
}
-keepclassmembers enum * {
public static **[] values();
public static ** valueOf(java.lang.String);
}
-keepclassmembers class * implements java.io.Serializable {
static final long serialVersionUID;
private static final java.io.ObjectStreamField[] serialPersistentFields;
private void writeObject(java.io.ObjectOutputStream);
private void readObject(java.io.ObjectInputStream);
java.lang.Object writeReplace();
java.lang.Object readResolve();
}
-keep class * implements android.os.Parcelable {
public static final android.os.Parcelable$Creator *;
}
posted @
2014-10-21 11:37 Terry Zou 阅读(228) |
评论 (0) |
编辑 收藏
例子如下：
1 File file = new File(filePath);
2 if(file.exists()){
3 String END = "\r\n";
4 String PREFIX = "--" ;
5 String BOUNDARY = UUID.randomUUID().toString(); //边界标识 随机生成
6 String CONTENT_TYPE = "multipart/form-data"; //内容类型
7
8 InputStream inputStream = null;
9 FileInputStream fileStream = null;
10 DataOutputStream dos = null;
11 HttpURLConnection conn = null;
12 try {
13 URL url = new URL(Constant.URL_SECONDHAN_TAKEPHOTOATHAND);
14 conn = (HttpURLConnection) url.openConnection();
15 /*设置时间*/
16 conn.setReadTimeout(10*1000);
17 conn.setConnectTimeout(10*1000);
18
19 /*允许Input,output,不使用Cache*/
20 conn.setDoInput(true);
21 conn.setDoOutput(true);
22 conn.setUseCaches(false);
23
24 /*设置传送的method=POST*/
25 conn.setRequestMethod("POST");
26 conn.setRequestProperty("Connection", "Keep-Alive");
27 conn.setRequestProperty("Charset", "UTF-8");
28 conn.setRequestProperty("Content-Type", CONTENT_TYPE + ";boundary=" + BOUNDARY);
29
30 /* 设置DataOutputStream */
31 dos = new DataOutputStream(conn.getOutputStream());
32
33 StringBuffer sb = new StringBuffer();
34 sb.append(PREFIX);
35 sb.append(BOUNDARY);
36 sb.append(END);
37 /**
38 * 这里重点注意：
39 * name里面的值为服务器端需要key 只有这个key 才可以得到对应的文件
40 * filename是文件的名字，包含后缀名的 比如:abc.png
41 */
42 sb.append("Content-Disposition: form-data; name=\"UpLoadFile\"; filename=\""+file.getName()+"\""+END);
43 sb.append("Content-Type: application/x-zip-compressed; charset=utf-8"+END);
44 sb.append(END);
45 dos.write(sb.toString().getBytes());
46
47 /*取得文件的FileInputStream*/
48 fileStream = new FileInputStream(file);
49
50 /*设置每次写入1024bytes*/
51 int bufferSize = 1024;
52 byte[] buffer = new byte[bufferSize];
53 int length = -1;
54
55 /*从文件读取数据至缓冲区*/
56 while((length=fileStream.read(buffer))!=-1){
57 dos.write(buffer,0,length);
58 }
59 dos.write(END.getBytes());
60 byte[] end_data = (PREFIX+BOUNDARY+PREFIX+END).getBytes();
61 dos.write(end_data);
62 dos.flush();
63
64 /* 取得Response内容 */
65 InputStream is = conn.getInputStream();
66 int ch;
67 StringBuffer b =new StringBuffer();
68 while( ( ch = is.read() ) != -1 ){
69 b.append( (char)ch );
70 }
71 String result = b.toString();
72
73 } catch (SocketTimeoutException e) {
74 AgUtils.log("", " upload SocketTimeoutException");
75 mHandler.sendEmptyMessage(4);
76 e.printStackTrace();
77 } catch (ConnectTimeoutException e) {
78 AgUtils.log("", " download ConnectTimeoutException");
79 mHandler.sendEmptyMessage(4);
80 e.printStackTrace();
81 } catch (UnknownHostException e) {
82 AgUtils.log("", " download UnknownHostException");
83 mHandler.sendEmptyMessage(4);
84 e.printStackTrace();
85 } catch (MalformedURLException e) {
86 AgUtils.log("", " download MalformedURLException");
87 mHandler.sendEmptyMessage(4);
88 e.printStackTrace();
89 } catch (ProtocolException e) {
90 AgUtils.log("", " ProtocolException");
91 e.printStackTrace();
92 mHandler.sendEmptyMessage(2);
93 } catch (IOException e) {
94 AgUtils.log("", " IOException");
95 mHandler.sendEmptyMessage(0);
96 e.printStackTrace();
97 } finally {
98 XqshService.this.sendBroadcast(new Intent(INTENT_UPLOAD_COMPLETE));
99 try {
100 if (fileStream != null) {
101 fileStream.close();
102 }
103 if (inputStream != null) {
104 inputStream.close();
105 }
106 if (dos != null) {
107 dos.close();
108 }
109
110 if (conn != null) {
111 conn.disconnect();
112 conn = null;
113 }
114 } catch (IOException e) {
115 e.printStackTrace();
116 }
117 }
118 }
posted @
2014-09-11 08:16 Terry Zou 阅读(176) |
评论 (0) |
编辑 收藏
1.建立FrameLayout,因为该布局方式只显示下层内容，如：
1 <FrameLayout
2 xmlns:android="http://schemas.android.com/apk/res/android"
3 android:layout_width="match_parent"
4 android:layout_height="fill_parent">
5 <LinearLayout
6 android:layout_width="fill_parent"
7 android:layout_height="fill_parent"
8 android:orientation="vertical"
9 android:id="@+id/main"
10 android:background="@color/white"
11 >
12 <LinearLayout
13 android:layout_width="fill_parent"
14 android:layout_height="wrap_content"
15 >
16 <GridView
17 android:id="@+id/gridview_send"
18 android:layout_width="fill_parent"
19 android:layout_height="fill_parent"
20 android:layout_marginLeft="20dp"
21 android:layout_marginTop="40dp"
22 android:listSelector="@color/bule_overlay"
23 android:numColumns="4" >
24 </GridView>
25 </LinearLayout>
26 <ImageView
27 android:layout_width="fill_parent"
28 android:layout_height="wrap_content"
29 android:src="@drawable/service_public_diver"
30 android:layout_marginLeft="20dp"
31 android:layout_marginRight="20dp"
32 android:layout_marginTop="40px"
33 />
34 <EditText
35 android:id="@+id/issueContent"
36 android:layout_width="fill_parent"
37 android:layout_height="wrap_content"
38 android:minLines="4"
39 android:gravity="top"
40 android:layout_marginLeft="20dp"
41 android:layout_marginRight="20dp"
42 android:layout_marginTop="30px"
43 android:textColor="#e3e3e3"
44 android:hint="请输入内容"
45 android:background="@null"
46 android:textSize="46px"/>
47 <ImageView
48 android:layout_width="fill_parent"
49 android:layout_height="wrap_content"
50 android:src="@drawable/service_public_diver"
51 android:layout_marginLeft="20dp"
52 android:layout_marginRight="20dp"
53 android:layout_marginTop="40dp"
54 />
55 </LinearLayout>
56 <LinearLayout
57 android:id="@+id/layerMask"
58 android:layout_width="fill_parent"
59 android:layout_height="fill_parent"
60 android:orientation="vertical"
61 android:background="@drawable/common_title_back"
62 android:visibility="gone">
63 </LinearLayout>
64 </FrameLayout>
2.在layerMasK中添加view内容
private LinearLayout layerMask;//遮罩层
layerMask = (LinearLayout)contentView.findViewById(R.id.layerMask);
addInnerLayout(R.layout.fragment_takephotoathand_layer,layerMask);
//设置点击不退出遮罩层
layerMask.setOnTouchListener(new OnTouchListener(){
@Override
public boolean onTouch(View v, MotionEvent event) {
return true;
}
});
private void addInnerLayout(int layoutResID,LinearLayout view){
LayoutInflater inflater = (LayoutInflater) ((Activity) mContext).getLayoutInflater();
View CurView = inflater.inflate(layoutResID, null);
LinearLayout.LayoutParams lineparam = new LinearLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT,
RelativeLayout.LayoutParams.MATCH_PARENT);
view.addView(CurView,lineparam);
}
3.控制显示
layerMask.setVisibility(View.VISIBLE);
posted @
2014-09-11 08:13 Terry Zou 阅读(1233) |
评论 (0) |
编辑 收藏 1.FLAG_ACTIVITY_CLEAR_TOP：例如现在的栈情况为：A B C D 。D此时通过intent跳转到B，如果这个intent添加FLAG_ACTIVITY_CLEAR_TOP标记，则栈情况变为：A B。如果没有添加这个标记，则栈情况将会变成：A B C D B。也就是说，如果添加了FLAG_ACTIVITY_CLEAR_TOP标记，并且目标Activity在栈中已经存在，则将会把位于该目标activity之上的activity从栈中弹出销毁。这跟上面把B的Launch mode设置成singleTask类似。简而言之，跳转到的activity若已在栈中存在，则将其上的activity都销掉。
2.FLAG_ACTIVITY_NEW_TASK：例如现在栈1的情况是：A B C。C通过intent跳转到D，并且这个intent添加了FLAG_ACTIVITY_NEW_TASK标记，如果D这个Activity在Manifest.xml中的声明中添加了Task affinity，系统首先会查找有没有和D的Task affinity相同的task栈存在，如果有存在，将D压入那个栈，如果不存在则会新建一个D的affinity的栈将其压入。如果D的Task affinity默认没有设置，则会把其压入栈1，变成：A B C D，这样就和不加FLAG_ACTIVITY_NEW_TASK标记效果是一样的了。注意如果试图从非activity的非正常途径启动一个activity（例见下文“intent.setFlags()方法中参数的用例”），比如从一个service中启动一个activity，则intent比如要添加FLAG_ACTIVITY_NEW_TASK标记（编者按：activity要存在于activity的栈中，而非activity的途径启动activity时必然不存在一个activity的栈，所以要新起一个栈装入启动的activity）。简而言之，跳转到的activity根据情况，可能压在一个新建的栈中。
3.FLAG_ACTIVITY_NO_HISTORY：例如现在栈情况为：A B C。C通过intent跳转到D，这个intent添加FLAG_ACTIVITY_NO_HISTORY标志，则此时界面显示D的内容，但是它并不会压入栈中。如果按返回键，返回到C，栈的情况还是：A B C。如果此时D中又跳转到E，栈的情况变为：A B C E，此时按返回键会回到C，因为D根本就没有被压入栈中。简而言之，跳转到的activity不压在栈中。
4.FLAG_ACTIVITY_SINGLE_TOP：和Activity的Launch mode的singleTop类似。如果某个intent添加了这个标志，并且这个intent的目标activity就是栈顶的activity，那么将不会新建一个实例压入栈中。简而言之，目标activity已在栈顶则跳转过去，不在栈顶则在栈顶新建activity。
二.intent.setFlags()方法中参数的用例：
很多人使用startActivity时候，会碰到如下的异常：
Caused by: android.util.AndroidRuntimeException: Calling startActivity() from outside of an Activity context requires the FLAG_ACTIVITY_NEW_TASK flag. Is this really what you want?
都知道，Context中有一个startActivity方法，Activity继承自Context，重载了startActivity方法。如果使用Activity的startActivity方法，不会有任何限制，而如果使用Context的startActivity方法的话，就需要开启一个新的task（编者按：参见一.2.的编者按），遇到上面那个异常的，都是因为使用了Context的startActivity方法。解决办法是：Java代码中加一个flag，即intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)。这样就可以在新的task里面启动这个Activity了。
posted @
2014-05-28 17:43 Terry Zou 阅读(144) |
评论 (0) |
编辑 收藏
摘要: 转自：http://musicbox95351.iteye.com/blog/868526 比如项目为一个UserServlet，主要分三步 1 日志输出文件log4j.xml的配置。 2 加载日志配置...
阅读全文
posted @
2014-05-26 11:13 Terry Zou 阅读(1408) |
评论 (0) |
编辑 收藏- 概述NFC标签和四类标签的定义。
近场通讯技术的关键要素之一，在于NFC装置与被动式NFC标签沟通的能力。NFC技术的这一特征，是许多应用成为可能的关键
NFC标签正在被大量生产、部署在全球若干个领域。部署的标签已逾百万，随着该技术流行，NFC标签将渗入到很多新的领域。
预测到未来将有大量标签得到使用，标签的定义必须清晰，已确保不同制造商的标签与设备达到兼容。
- NFC标签基础
NFC标签是被动式装置，可用来与主动式NFC装置（主动式NFC读写器）通信。标签可用于应用之内，例如在海报、以及其他储存小量数据并传输到主动式NFC装置的场合。在海报中，起作用的部分可用来做主动设备的接触点。
NFC标签所含储存的数据可为任何形式，但一般是用来贮存网址（URL）以供NFC装置找到进一步的信息。所需数据量很少，故可使用NFC标签。
为了定义主动式NFC读写器与被动式标签之间的通信，NFC论坛在2006年6月推出了其第一个标准技术架构和NFC合规装置的标准，包括：NFC数据交换格式（NDEF）、三种记录类型定义（RTD），用于智能海报、文本、互联网资源读取应用。
- NFC标签类型定义
定义的基本标签类型有四种，以1至4来标识，各有不同的格式与容量。这些标签类型格式的基础是：ISO 14443的A与B类型、Sony FeliCa，前者是非接触式智能卡的国际标准，而后者符合ISO 18092被动式通讯模式标准。
保持NFC标签尽可能简单的优势是：在很多场合，标签可为一次性使用，例如在海报中寿命较短的场合。
各种标签的定义如下：
第1类标签（Tag 1 Type）：此类型基于ISO14443A标准。此类标签具有可读、重新写入的能力，用户可将其配置为只读。存储能力为96字节，用来存网址URL或其他小量数据富富有余。然而，内存可被扩充到2k字节。此类NFC标签的通信速度为106 kbit/s。此类标签简洁，故成本效益较好，适用于许多NFC应用。
第2类标签（Tag 2 Type）：此类标签也是基于ISO14443A，具有可读、重新写入的能力，用户可将其配置为只读。其基本内存大小为48字节，但可被扩充到2k字节。通信速度也是106 kbit/s。
第3类标签（Tag 3 Type）：此类标签基于Sony FeliCa体系。目前具有2k字节内存容量，数据通讯速度为212 kbit/s。故此类标签较为适合较复杂的应用，尽管成本较高。
第4类标签（Tag 4 Type）：此类标签被定义为与ISO14443A、B标准兼容。制造时被预先设定为可读/可重写、或者只读。内存容量可达32k字节，通信速度介于106 kbit/s和424 kbit/s之间。
从上述不同标签类型的定义可以看出，前两类与后两类在内存容量、构成方面大不相同。故它们的应用不太可能有很多重叠。
第1与第2类标签是双态的，可为读/写或只读。第3与第4类则是只读，数据在生产时写入或者通过特殊的标签写入器来写入。
-NFC标签运行
NFC标签是无需电源的被动装置。在使用时，用户以具有NFC功能的设备与其接触。标签从读写器获得很小的电源驱动标签的电路，把小量信息传输到读写器。
标签内存里的数据被传至带有NFC功能的设备。尽管数据量很小，却可能是把设备导向到某个网址（URL）、或是小量文本、其他数据。
-NFC标签设计与制造
标签设计与制造需要考虑很多方面。标签是为了大量、极低成本制造，同时保持性能。在设计标签时，下面是需要考虑的几个关键的性能参数与要素：
读取速度：因为需要在两个NFC装置接近时传输标签所含的所有数据，故速度很重要。如果标签传数据较慢，就有不能完全传输、可靠性差的危险。结果影响到用户，不明白该技术的用户，假如不得不重复多次才能奏效就会对其丧失信心。第一类NFC标签允许所有数据整块（block）传输，保持了标签的读取性能。
晶片尺寸：在标签设计中，晶片尺寸（die size）具有特别的重要性。尺寸较小，则成本较低、标签也不那么显眼（对在海报中使用较为重要）。内存较小自然导致晶片尺寸较小。
单元价格：鉴于NFC标签的目标应用是极低成本的（例如用于智能海报），单位价格是标签设计极其重要的一个因素。在这里，成本至为关键。标签成本受一系列因素影响，包括内存大小和所含附加特征带来的集成电路复杂性。把内存与特征尽可能简化，成本就能压低。
当NFC体系真正起飞时，标签生产量可能达到数十亿的规模；需要精心设计，以在成本与性能之间取得正确的平衡。
posted @
2014-05-16 10:33 Terry Zou 阅读(197) |
评论 (0) |
编辑 收藏问题：按照NDEF消息格式来解析下列Hex串?
D1 02 1F 53 70 91 01 0E 54 02
65 6E 68 65 6C 6C 6F 20 77 6F
72 6C 64 51 01 09 55 01 73 69
6E 61 2E 63 6F 6D
解答：
(1)NDEF记录格式如下，
Byte 0: D1
0xD1 = 11010001B，对应的标志位如下：
MB(Message Begin) = 1，说明这是首记录
ME(Message End) = 1，说明这是末记录(说明消息只有一个记录)
CF(Chunk Flag) = 0，说明记录未被切块
SR(Short Record) = 1，说明这是短记录，PAYLOAD_LENGTH 占1字节
IL(ID_LENGTH field is present) = 0，说明没有 ID_LENGTH 和 ID 域
TNF(Type Name Format) = 1，说明TYPE类型是 NFC Forum well-known type [NFC RTD],
下表是TNF编码对应表
因为SR=1且IL=0，所以NDEF记录可简化为如下结构 
Byte 1: 02
TYPE_LENGTH = 2，TYPE域长度为2
Byte 2: 1F
PAYLOAD_LENGTH = 0x1F，Payload域长度为31
Byte 3-4: 53 70
TYPE = "Sp"，因为TYPE域长度为2，所以此处TYPE取2个字节
此后全是PAYLOAD域的内容，因为TYPE="Sp"，所以需要使用的Spec是“Smart Poster Record Type Definition”
（2）智能海报的记录类型其实也是一个NDEF消息。没错，NDEF记录的PAYLOAD域可以存放任何东西，包括嵌套NDEF消息。
智能海报的内容可以包括标题、URI、动作、图标、大小、类型等记录，其中URI记录是必须有的，其他的可选，次序无所谓。
1）现在将智能海报的内容贴过来，如下
91 01 0E 54 02 65 6E 68 65 6C
6C 6F 20 77 6F 72 6C 64 51 01
09 55 01 73 69 6E 61 2E 63 6F
6D
Byte 0: 91
0x91 = 10010001B，对应的标志位如下：
MB = 1，说明这是首记录
ME = 0，说明后面还有记录
CF = 0，说明记录未被切块
SR = 1，说明这是短记录，PAYLOAD_LENGTH 占1字节
IL = 0，说明没有 ID_LENGTH 和 ID 域
TNF = 1，说明TYPE类型是 NFC Forum well-known type
Byte 1: 01
TYPE_LENGTH = 1，TYPE域长度为1
Byte 2: 0E
PAYLOAD_LENGTH = 0x0E，Payload域长度为14
Byte 3: 54
TYPE = "T"，说明是文本记录类型，适用“Text Record Type Definition”
Byte 4-17: 02 65 6E 68 65 6C 6C 6F 20 77 6F 72 6C 64
这是文本记录的内容
下面对“02 65 6E 68 65 6C 6C 6F 20 77 6F 72 6C 64”按照文本记录格式解码。
文本记录格式如下：
Byte 0: 02
Status = 2，由下表可知，IANA语言码长度=2
Byte 1-2: 65 6E
ISO/IANA语言码 = “en”，编码为US-ASCII码
Byte 3-13：68 65 6C 6C 6F 20 77 6F 72 6C 64
按照ASCII码解码可得“hello world”
至此，对海报内容的第一条NDEF记录解码完成，接下来是对剩余内容解码。
2）剩余内容为“51 01 09 55 01 73 69 6E 61 2E 63 6F 6D”，同样也是按照NDEF记录来解码。
Byte 0: 51
0x91 = 01010001B，对应的标志位如下：
MB = 0，说明这不是首记录
ME = 1，说明这是末记录
CF = 0，说明记录未被切块
SR = 1，说明这是短记录，PAYLOAD_LENGTH 占1字节
IL = 0，说明没有 ID_LENGTH 和 ID 域
TNF = 1，说明TYPE类型是 NFC Forum well-known type
Byte 1: 01
TYPE_LENGTH = 1，TYPE域长度为1
Byte 2: 09
PAYLOAD_LENGTH = 0x09，Payload域长度为9
Byte 3: 55
TYPE = "U"，说明是URI记录类型，适用“URI Record Type Definition”
Byte 4-12: 01 73 69 6E 61 2E 63 6F 6D
这是URI记录的内容
URI记录内容格式如下：
Byte 0: 01
ID码 = 1，由下表可知，对应的协议是“http://www.”
Byte 1-8: 73 69 6E 61 2E 63 6F 6D
按照UTF-8格式解码可得：“sina.com”
至此，整个NDEF消息解码完毕。
回顾一下吧，整个结构的解码将其如下分解：
D1 02 1F 53 70 <-- 智能海报
91 01 0E 54 02 65 6E 68 65 6C 6C 6F 20 77 6F 72 6C 64 <-- 文本
51 01 09 55 01 73 69 6E 61 2E 63 6F 6D <-- URI
posted @
2014-05-14 16:17 Terry Zou 阅读(1800) |
评论 (0) |
编辑 收藏
摘要: AsyncTask和Handler对比
1 ） AsyncTask实现的原理,和适用的优缺点
AsyncTask,是android提供的轻量级的异步类,可以直接继承AsyncTask,在类中实现异步操作,并提供接口反馈当前异步执行的程度(可以通过接口实现UI进度更新),最后反馈执行的结果给UI主线程.
使用的优点:
l 简单,快捷
l 过程可控
&n...
阅读全文
posted @
2014-05-08 17:25 Terry Zou 阅读(167) |
评论 (0) |
编辑 收藏posted @
2014-03-21 16:50 Terry Zou 阅读(3426) |
评论 (0) |
编辑 收藏
摘要: JAVA卡介绍
JAVA卡与智能卡
什么是 JAVA 卡呢？JAVA 卡是一种可以运行 JAVA 程序的接触式微处理器智能卡。1996 年 11 月，JAVA 卡 1.0 版本的规范正式发布了。如今 JAVA&n...
阅读全文
posted @
2014-03-14 17:48 Terry Zou 阅读(197) |
评论 (0) |
编辑 收藏Hibernate 默认总共支持 13 种生成策略 :
1. increment 2. identity 3. sequence
4. hilo 5. seqhilo 6. uuid
7. uuid.hex 8. guid 9. native
10. assigned 11. select 12. foreign 13. sequence-identity
下面介绍几个较为常用的策略 :
① identity [ 自然递增 ]
支持 DB2，MySQL，SQL Server，Sybase 和HypersonicSQL 数据库， 用于为 long 或 short 或 int 类型生成唯一标识。它依赖于底层不同的数据库，
与 Hibernate 和 程序员无关。
注解示例 :
@Id
@GenericGenerator(name = "idGenerator", strategy = "identity")
@GeneratedValue(generator = "idGenerator")
② sequence [ 序列 ]
支持 Oracle，DB2，PostgreSql，SAPDb 等数据库，用于为 long 或 short 或 int 类型生成唯一标识。它需要底层数据库的支持，
并由数据库来维护这个 sequence 序列。
注解示例 :
@Id
@GenericGenerator(name = "idGenerator", strategy = "sequence",
parameters = {@Parameter(name = "sequence",value="seq_name")})
@GeneratedValue(generator = "idGenerator")
注意 : 该策略要求设定序列名，否则 hibernate 将无法找到，这将引致抛出异常 :
org.hibernate.exception.SQLGrammarException: could not get next sequence value
③ native
需底层数据库的支持，对于 MySQL，SQL Server 采用 identity 的生成策略，对于 Oracle，则采用 sequence 策略。
注解示例 :
@Id
@GenericGenerator(name = "idGenerator", strategy = "native")
@GeneratedValue(generator = "idGenerator")
④ increment [ 自然递增 ]
与 identity 策略不同的是，该策略不依赖于底层数据库，而依赖于 hibernate 本身，用于为 long 或 short 或 int 类型生成唯一标识。
主键计数器是由 hibernate 的一个实例来维护，每次自增量为 1，但在集群下不能使用该策略，
否则将引起主键冲突的情况，该策略适用于所有关系型数据库使用。
注解示例 :
@Id
@GenericGenerator(name = "idGenerator", strategy = "increment")
@GeneratedValue(generator = "idGenerator")
⑤ uuid [ 32位16进制数的字符串 ]
采用128位UUID算法生成主键，能够保证网络环境下的主键唯一性，也就能够保证在不同数据库及不同服务器下主键的唯一性。
uuid 最终被编码成一个32位16进制数的字符串，
占用的存储空间较大。用于为 String 类型生成唯一标识，适用于所有关系型数据库。
注解示例 :
@Id
@GenericGenerator(name = "idGenerator", strategy = "uuid")
@GeneratedValue(generator = "idGenerator")
⑤ assigned [ 手工分配主键ID值 ]
该策略要求程序员必须自己维护和管理主键，当有数据需要存储时，程序员必须自己为该数据分配指定一个主键ID值，
如果该数据没有被分配主键ID值或分配的值存在重复，则该数据都将无法被持久化且会引起异常的抛出。
注解示例 :
@Id
@GenericGenerator(name = "idGenerator", strategy = "assigned")
@GeneratedValue(generator = "idGenerator")
[ 随笔均原创，转载请注明出处：http://www.blogjava.net/fancydeepin ]
posted @
2014-03-06 16:13 Terry Zou 阅读(205) |
评论 (0) |
编辑 收藏Android开发的过程中，每次调用startService(Intent)的时候，都会调用该Service对象的onStartCommand(Intent,int,int)方法，然后在onStartCommand方法中做一些处理。然后我们注意到这个函数有一个int的返回值，这篇文章就是简单地讲讲int返回值的作用。
从Android官方文档中，我们知道onStartCommand有4种返回值：
START_STICKY：如果service进程被kill掉，保留service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建service，由于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(Intent,int,int)方法。如果在此期间没有任何启动命令被传递到service，那么参数Intent将为null。
START_NOT_STICKY：“非粘性的”。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务。
START_REDELIVER_INTENT：重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入。
START_STICKY_COMPATIBILITY：START_STICKY的兼容版本，但不保证服务被kill后一定能重启。
可能导致异常如下
java.lang.RuntimeException: Unable to start service
serviceName with null: java.lang.NullPointerException
at android.app.ActivityThread.handleServiceArgs(ActivityThread.java:3221)
at android.app.ActivityThread.access$2100(ActivityThread.java:156)
at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1461)
at android.os.Handler.dispatchMessage(Handler.java:102)
at android.os.Looper.loop(Looper.java:157)
at android.app.ActivityThread.main(ActivityThread.java:5872)
at java.lang.reflect.Method.invokeNative(Native Method)
at java.lang.reflect.Method.invoke(Method.java:515)
at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:1069)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:885)
at dalvik.system.NativeStart.main(Native Method)
Caused by: java.lang.NullPointerException
at com.ag.rhg.download.DownloadPassService.onStart(Unknown Source)
at android.app.Service.onStartCommand(Service.java:450)
at android.app.ActivityThread.handleServiceArgs(ActivityThread.java:3187)
... 10 more
解决办法：在Service onStart方法中做判断
if (null != intent) {
。。。。。。。
}
posted @
2014-02-26 15:50 Terry Zou 阅读(890) |
评论 (0) |
编辑 收藏
第一、 新建监听类：BootReceiver继承BroadcastReceiver
public class BootReceiver extends BroadcastReceiver 
{
@Override
public void onReceive(Context context, Intent intent) {
//接收广播：系统启动完成后运行程序
if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED")) {
Intent newIntent = new Intent(context, WatchInstall.class);
newIntent.setAction("android.intent.action.MAIN");
newIntent.addCategory("android.intent.category.LAUNCHER");
newIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(newIntent);
}
//接收广播：设备上新安装了一个应用程序包后自动启动新安装应用程序。
if (intent.getAction().equals("android.intent.action.PACKAGE_ADDED")) {
String packageName = intent.getDataString().substring(8);
System.out.println("---------------" + packageName);
Intent newIntent = new Intent();
newIntent.setClassName(packageName,packageName+ .MainActivity");
newIntent.setAction("android.intent.action.MAIN");
newIntent.addCategory("android.intent.category.LAUNCHER");
newIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(newIntent);
}
//接收广播：设备上删除了一个应用程序包。
if (intent.getAction().equals("android.intent.action.PACKAGE_REMOVED")) {
System.out.println("********************************");
DatabaseHelper dbhelper = new DatabaseHelper();
dbhelper.executeSql("delete from users");
}
}
<?xml version="1.0" encoding="UTF-8"?>
<manifest xmlns:android="
http://schemas.android.com/apk/res/android"
package="org.me.watchinstall">
<application>
<receiver android:name=".BootReceiver"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED"/>
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.PACKAGE_ADDED" />
<action android:name="android.intent.action.PACKAGE_REMOVED" />
<data android:scheme="package" />
<!--[color=red] 注意！！ 这句必须要加，否则接收不到BroadCast [/color] -->
</intent-filter>
</receiver>
<activity android:name=".WatchInstall" android:label="WatchInstall">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
</application>
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.RESTART_PACKAGES"/>
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
</manifest>
posted @
2014-02-14 14:37 Terry Zou 阅读(178) |
评论 (0) |
编辑 收藏
1.new->Java Card Project
2.new->Java Card Applet Class->AID Settings
编写卡内程序
public class HelloApplet extends Applet {
public static void install(byte[] bArray, short bOffset, byte bLength) {
// GP-compliant JavaCard applet registration
new HelloApplet().register(bArray, (short) (bOffset + 1),
bArray[bOffset]);
}
public void process(APDU apdu) {
// Good practice: Return 9000 on SELECT
if (selectingApplet()) {
return;
}
byte[] buf = apdu.getBuffer();
short offset = ISO7816.OFFSET_CDATA;
switch (buf[ISO7816.OFFSET_INS]) {
case (byte) 0xE2:
buf[offset++] = 0x01;
buf[offset++] = 0x02;
buf[offset++] = 0x03;
buf[offset++] = 0x04;
buf[offset++] = 0x05;
buf[offset++] = 0x06;
apdu.setOutgoingAndSend(ISO7816.OFFSET_CDATA, (short)(offset-ISO7816.OFFSET_CDATA));
break;
case (byte) 0xE3:
buf[offset++] = 0x11;
buf[offset++] = 0x12;
buf[offset++] = 0x13;
buf[offset++] = 0x14;
buf[offset++] = 0x15;
buf[offset++] = 0x16;
apdu.setOutgoingAndSend(ISO7816.OFFSET_CDATA,(short) (offset-ISO7816.OFFSET_CDATA));
break;
default:
ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
}
}
}
3.右键项目->Run Configurations...->Java Card Application右键选择new->选择新建的Applet->package Upload->aid
4.新建卡外项目java project
编写卡内程序如下：
public class TestHelloWorld {
protected static RFCSMXIO smxio = null;
@Before
public void setUp() throws Exception {
smxio = SMXIOFactory.createJDKSMXIO();
}
@Test
public void test() {
try {
byte[] aid = ByteUtil.hexToByteArray("5200413120");
RFCIOResult result = smxio.selectApplet(aid);
int offset = 0;
byte[] apdu = new byte[5];
apdu[offset] = (byte)0x80;
apdu[offset+1] = (byte)0xE2;
apdu[offset+2] = 0;
apdu[offset+3] = 0;
apdu[offset+4] = 0;
result = smxio.exchange(apdu);
System.out.println("result: "+ByteUtil.byteArrayToHex(result.getResult()));
boolean res = RFCSMXIOHelper.processCardIOResult(result);
byte[] b = result.getResult();
if(res){
System.out.println(ByteUtil.byteArrayToHex(b));
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
6.安装卡内程序
jcop debug->upload package->install applet
7.运行卡外程序
posted @
2014-01-23 11:38 Terry Zou 阅读(182) |
评论 (0) |
编辑 收藏
摘要: Hibernate 参数设置一览表
SQL方言
1、Hibernate JDBC属性
属性名
用途
hibernate.connection.driver_class
jdbc驱动类
hibernate.connection.url
jdbc URL
hibernate.connection.username
数据库用户
...
阅读全文
posted @
2014-01-22 10:18 Terry Zou 阅读(153) |
评论 (0) |
编辑 收藏
原因1，这中情况有时候是jar包中缺少需要的类，没把需要的类打进去
原因2，缺少default.properties文件
从其他工程拷贝一个过来
原因3，没有jar包，没有资源文件
工程右键 -> Properties ->android ->选择一个android的版本，（如果已经选择好了，还是有问题，就先选择另一个，之后再换回来）
posted @
2014-01-21 15:21 Terry Zou 阅读(169) |
评论 (0) |
编辑 收藏1.缺少包commons-collections-3.1.jar
java.lang.NoClassDefFoundError: org/apache/commons/collections/map/LRUMap
at org.hibernate.util.SimpleMRUCache.init(SimpleMRUCache.java:71)
at org.hibernate.util.SimpleMRUCache.<init>(SimpleMRUCache.java:55)
at org.hibernate.engine.query.QueryPlanCache.<init>(QueryPlanCache.java:76)
at org.hibernate.impl.SessionFactoryImpl.<init>(SessionFactoryImpl.java:239)
at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1872)
at org.hibernate.ejb.Ejb3Configuration.buildEntityManagerFactory(Ejb3Configuration.java:906)
at org.hibernate.ejb.HibernatePersistence.createEntityManagerFactory(HibernatePersistence.java:57)
at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:63)
at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:47)
at com.rfcyber.rfcepayment.util.jpa.JPAHelper.init(Unknown Source)
at test.TestDataPreparation.setUp(TestDataPreparation.java:52)
at junit.framework.TestCase.runBare(TestCase.java:128)
at junit.framework.TestResult$1.protect(TestResult.java:106)
at junit.framework.TestResult.runProtected(TestResult.java:124)
at junit.framework.TestResult.run(TestResult.java:109)
at junit.framework.TestCase.run(TestCase.java:120)
at org.eclipse.jdt.internal.junit.runner.junit3.JUnit3TestReference.run(JUnit3TestReference.java:130)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)
Caused by: java.lang.ClassNotFoundException: org.apache.commons.collections.map.LRUMap
at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)
... 22 more
2.缺jta.jar
java.lang.NoClassDefFoundError: javax/transaction/SystemException
at org.hibernate.ejb.EntityManagerFactoryImpl.createEntityManager(EntityManagerFactoryImpl.java:112)
at org.hibernate.ejb.EntityManagerFactoryImpl.createEntityManager(EntityManagerFactoryImpl.java:107)
at com.rfcyber.rfcepayment.util.jpa.JPAHelper.getEntityManager(Unknown Source)
at com.rfcyber.rfcepayment.util.jpa.JPADAO.findByJPQL(Unknown Source)
at com.richhouse.personal.service.DPZYTService.searchNextAvaiable(Unknown Source)
at com.richhouse.personal.util.ZYTDPHandler.searchNextAvaiable(Unknown Source)
at com.richhouse.personal.util.ZYTDataPreparation.prepareStoreData(Unknown Source)
at test.TestDataPreparation.testOracleSearchNext(TestDataPreparation.java:91)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at junit.framework.TestCase.runTest(TestCase.java:164)
at junit.framework.TestCase.runBare(TestCase.java:130)
at junit.framework.TestResult$1.protect(TestResult.java:106)
at junit.framework.TestResult.runProtected(TestResult.java:124)
at junit.framework.TestResult.run(TestResult.java:109)
at junit.framework.TestCase.run(TestCase.java:120)
at org.eclipse.jdt.internal.junit.runner.junit3.JUnit3TestReference.run(JUnit3TestReference.java:130)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)
Caused by: java.lang.ClassNotFoundException: javax.transaction.SystemException
at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)
... 24 more
posted @
2014-01-15 10:44 Terry Zou 阅读(290) |
评论 (0) |
编辑 收藏
public static List<ApplicationInfo> getAllInstalledApp(Context context) {
List<ApplicationInfo> installedPackageList = new ArrayList<ApplicationInfo>();
List<ApplicationInfo> list = context.getPackageManager().getInstalledApplications(0);
for (int i = 0; i < list.size(); i++) {
installedPackageList.add(list.get(i));
}
return installedPackageList;
}
posted @
2014-01-14 16:07 Terry Zou 阅读(162) |
评论 (0) |
编辑 收藏1.流程
2.规范化
3.命名合理
posted @
2014-01-14 09:26 Terry Zou 阅读(144) |
评论 (0) |
编辑 收藏
摘要: oracle中imp命令详解命令：
exp 源库usr/源库pwd@源库连接符 tables=dp_zyt_dgi,dp_zyt_file,dp_zyt_card file=d:\test2.dmp full=n;
imp 目标库usr/目标库pwd@目标库连接符 file=test.dmp log=test_imp.log...
阅读全文
posted @
2014-01-13 20:04 Terry Zou 阅读(193) |
评论 (0) |
编辑 收藏
SharedPreferences是Android平台上一个轻量级的存储类，主要是保存一些常用的配置比如窗口状态，一般在Activity中 重载窗口状态onSaveInstanceState保存一般使用SharedPreferences完成，它提供了Android平台常规的Long长 整形、Int整形、String字符串型的保存，它是什么样的处理方式呢?SharedPreferences类似过去Windows系统上的ini配置文件，但是它分为多种权限，可以全局共享访问，android123提示最终是以xml方式来保存，整体效率来看不是特别的高，对于常规的轻量级而言比SQLite要好不少，如果真的存储量不大可以考虑自己定义文件格式。xml 处理时Dalvik会通过自带底层的本地XML Parser解析，比如XMLpull方式，这样对于内存资源占用比较好。
这种方式应该是用起来最简单的Android读写外部数据的方法了。他的用法基本上和 J2SE(java.util.prefs.Preferences)中的用法一样，以一种简单、 透明的方式来保存一些用户个性化设置的字体、颜色、位置等参数信息。一般的应用程序都会提供“设置”或者“首选项”的这样的界面，那么这些设置最后就可以 通过Preferences来保存，而程序员不需要知道它到底以什么形式保存的，保存在了什么地方。当然，如果你愿意保存其他的东西，也没有什么限制。只是在性能上不知道会有什么问题。
在Android系统中，这些信息以XML文件的形式保存在 /data/data/PACKAGE_NAME /shared_prefs 目录下。
下面举个例子如何高效的应用该类，比如QQ登录
public class SharePreferenceUtil {
private SharedPreferences sp;
private SharedPreferences.Editor editor;
public SharePreferenceUtil(Context context, String file) {
sp = context.getSharedPreferences(file, context.MODE_PRIVATE);
editor = sp.edit();
}
// 用户的密码
public void setPasswd(String passwd) {
editor.putString("passwd", passwd);
editor.commit();
}
public String getPasswd() {
return sp.getString("passwd", "");
}
// 用户的id，即QQ号
public void setId(String id) {
editor.putString("id", id);
editor.commit();
}
public String getId() {
return sp.getString("id", "");
}
// 用户的昵称
public String getName() {
return sp.getString("name", "");
}
public void setName(String name) {
editor.putString("name", name);
editor.commit();
}
// 用户的邮箱
public String getEmail() {
return sp.getString("email", "");
}
public void setEmail(String email) {
editor.putString("email", email);
editor.commit();
}
// 用户自己的头像
public Integer getImg() {
return sp.getInt("img", 0);
}
public void setImg(int i) {
editor.putInt("img", i);
editor.commit();
}
// ip
public void setIp(String ip) {
editor.putString("ip", ip);
editor.commit();
}
public String getIp() {
return sp.getString("ip", Constants.SERVER_IP);
}
// 端口
public void setPort(int port) {
editor.putInt("port", port);
editor.commit();
}
public int getPort() {
return sp.getInt("port", Constants.SERVER_PORT);
}
// 是否在后台运行标记
public void setIsStart(boolean isStart) {
editor.putBoolean("isStart", isStart);
editor.commit();
}
public boolean getIsStart() {
return sp.getBoolean("isStart", false);
}
// 是否第一次运行本应用
public void setIsFirst(boolean isFirst) {
editor.putBoolean("isFirst", isFirst);
editor.commit();
}
public boolean getisFirst() {
return sp.getBoolean("isFirst", true);
}
}
应用如下所示：
mAccounts = (EditText) findViewById(R.id.lgoin_accounts);
mPassword = (EditText) findViewById(R.id.login_password);
if (mAutoSavePassword.isChecked()) {
SharePreferenceUtil util = new SharePreferenceUtil(
LoginActivity.this, Constants.SAVE_USER);
mAccounts.setText(util.getId());
mPassword.setText(util.getPasswd());
}
posted @
2014-01-11 12:51 Terry Zou 阅读(152) |
评论 (0) |
编辑 收藏
public static void hel(int[] a,int[] b,int[] c){
System.arraycopy(a, 0, c, 0, a.length);
System.arraycopy(b, 0, c, a.length, b.length);
}
public void testabc(){
int[] str = new int[4];
int[] a = new int[]{1,2};
int[] b = new int[]{3,4};
hel(a,b, str);
for(int i=0;i<str.length;i++){
System.out.println(str[i]);
}
}
posted @
2013-12-25 11:39 Terry Zou 阅读(141) |
评论 (0) |
编辑 收藏
1.字节数组取反
public static byte[] backByte(byte[] buff){
for (int i=0;i<buff.length;i++){
int b=0;
for (int j=0;j<8;j++){
int bit = (buff[i]>>j&1)==0?1:0;
b += (1<<j)*bit;
}
buff[i]=(byte)b;
}
return buff;
} 2.查找字节数组中字数组的位置
public static int indexOf(byte[] src,int offset,byte[] needFind){
for(int i=offset;i<src.length-offset-needFind.length;i++){
boolean isValid=true;
for(int j=0;j<needFind.length;j++){
if(src[i+j]!=needFind[j]){
isValid=false;
break;
}
}
if(isValid){
return i;
}
}
return -1;
} 3.字节数组转换为16进制
private static final byte[] HEX_CHAR_TABLE = { (byte) '0', (byte) '1',
(byte) '2', (byte) '3', (byte) '4', (byte) '5', (byte) '6',
(byte) '7', (byte) '8', (byte) '9', (byte) 'A', (byte) 'B',
(byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F' };
public static String getHexString(byte[] raw, int len) {
byte[] hex = new byte[2 * len];
int index = 0;
int pos = 0;
for (byte b : raw) {
if (pos >= len)
break;
pos++;
int v = b & 0xFF;
hex[index++] = HEX_CHAR_TABLE[v >>> 4];
hex[index++] = HEX_CHAR_TABLE[v & 0xF];
}
return new String(hex);
}
posted @
2013-12-25 11:32 Terry Zou 阅读(706) |
评论 (0) |
编辑 收藏java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener
java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderListener
1.出现这个问题的原因有可能的其中一点就是spring的jar包没有被加载，有的时候没有拷spring的jar包会出现这个错误，但是当你拷了以后这个错误并没有消失的时候就说明jar包没有被加载，切记spring的jar包一定要放在工程的lib下这样才能避免这个错误的发生。
2.使用了重复的类库，且版本不一致。导致低版本的被优先使用。比如今天遇到一种情况在tomcat服务器使用了axis2.war包，当启动tomcat的时候，axis2.war包会自动解压，之后再该项目包里有相关的spring包，所以当有另外一个工程要到spring时，就有可能要到axis2的spring包，如果版本不一致就会导致该问题，解决的方法就是让该项目不受axis2项目包的影响。
posted @
2013-07-01 11:54 Terry Zou 阅读(1082) |
评论 (0) |
编辑 收藏https 双向认证配置：
1、生成服务器端密钥库 :
keytool -genkey -keyalg RSA -dname "cn=rtsm.nfcstore.com.cn,ou=a,o=a,l=a,st=a,c=cn" -alias server -keypass 123456 -keystore rhg_server.keystore -storepass 123456 -validity 365
2、导出服务端证书：
keytool -export -alias server -file nxp.crt -keystore rhg_server.keystore -storepass 123456 -rfc
3、生成浏览器（只能是PKCS12格式）证书
keytool -genkey -keyalg RSA -dname "cn=abc,ou=a,o=a,l=a,st=a,c=cn" -alias mock -storetype PKCS12 -keypass 123456 -keystore mock.p12 -storepass 123456 -validity 365
4. 导出浏览器证书
keytool -export -alias mock -file mock.crt -keystore mock.p12 -storepass 123456 -storetype PKCS12 -rfc
５、添加客户端证书到服务器中
keytool -import -v -alias mock -file mock.crt -keystore rhg_server.keystore -storepass 123456
６、添加服务端证书到客户端中
keytool -import -v -alias server -file nxp.crt -keystore mockTrust -storepass 123456
7. 查看证书内容
keytool -list -v -keystore rkmsTrust.keystore -storepass 123456
8. 删除证书
keytool -delete -alias xxx -keystore xxxx.keystore -storepass 123456
9. 修改keypass
keytool -keypasswd -alias xxx -keypass xxx -new 12345 -keystore xxx.keystore -storepass 123456
10. 修改storepass
keytool -storepasswd -keystore xxx.keystore -storepass 123456 -new xxx
Android BKS 证书
keytool -genkey -alias android -keypass 123456 -keyalg RSA -keysize 1024 -validity 365 -keystore android.keystore -storepass 123456 -dname "cn=android, ou=a, o=a, l=a, c=CN" -storetype BKS -provider org.bouncycastle.jce.provider.BouncyCastleProvider
keytool -export -alias android -file android.crt -keystore android.keystore -storetype BKS -storepass 123456 -provider org.bouncycastle.jce.provider.BouncyCastleProvider
keytool -import -v -alias rhgkms -file rhgkms.crt -keystore androidTrust.keystore -storetype BKS -storepass 123456 -provider org.bouncycastle.jce.provider.BouncyCastleProvider
posted @
2013-07-01 09:40 Terry Zou 阅读(360) |
评论 (0) |
编辑 收藏1.org.springframework.web.util.NestedServletException: Request processing failed; nested exception is org.apache.axiom.om.OMException: com.ctc.wstx.exc.WstxIOException: Invalid UTF-8 middle byte 0xfa (at char #193, byte #127)
org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:488)
org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:431)
javax.servlet.http.HttpServlet.service(HttpServlet.java:617)
javax.servlet.http.HttpServlet.service(HttpServlet.java:717)
org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:96)
org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:75)
org.springframework.orm.hibernate3.support.OpenSessionInViewFilter.doFilterInternal(OpenSessionInViewFilter.java:198)
org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:75)
com.adtech.libraryunion.filter.LoginFilter.doFilter(LoginFilter.java:54)
原因：调用接口的文件的编码方式不是UTF-8
解决：用记事本打开调用的文件,另存为UTF-8格式即可解决
2.web.xml中
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:applicationContext.xml</param-value>
</context-param>时
applicationContext.xml文件的位置在tomcat6.0.35\webapps\axis2\WEB-INF\classes目录下
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
applicationContext.xml文件的位置在tomcat6.0.35\webapps\axis2\WEB-INF\目录下
posted @
2013-06-25 17:01 Terry Zou 阅读(354) |
评论 (0) |
编辑 收藏
摘要: pull解析器
xml解析器有很多种，常见的有Jdom，dom4j等，pull解析xml为android系统所用到的解析器，是android自带的解析器。
preparation
1.项目结构
2...
阅读全文
posted @
2013-06-06 10:06 Terry Zou 阅读(189) |
评论 (0) |
编辑 收藏下面这个异常导致的原因可能为：用子线程更新的UI控件的值，比如：在一个线程中执行了Toast.makeText(this,"richhouse",5000);
UI控件画面的重绘（更新）是由主线程负责的，如果在子线程中更新UI控件的值，更新后的值不会重绘到屏幕上，一定要在主线程里更新UI控件的值，这样才能在屏幕上显示出来，不能在子线程中更新UI控件的值。
CRASH: com.richhouse.nfccenter (pid 2719)
// Short Msg: java.lang.IllegalStateException
// Long Msg: java.lang.IllegalStateException: The content of the adapter has changed but ListView did not receive a notification. Make sure the content of your adapter is not modified from a background thread, but only from the UI thread. [in ListView(2131230759, class android.widget.ListView) with Adapter(class android.widget.HeaderViewListAdapter)]
// Build Label: HTC/m7cdwg/m7cdwg:4.1.2/JZO54K/eng.buildteam.20130530.092435:userdebug/test-keys
// Build Changelist: eng.buildteam.20130530.092435
// Build Time: 1369877182000
// java.lang.IllegalStateException: The content of the adapter has changed but ListView did not receive a notification. Make sure the content of your adapter is not modified from a background thread, but only from the UI thread. [in ListView(2131230759, class android.widget.ListView) with Adapter(class android.widget.HeaderViewListAdapter)]
// at android.widget.ListView.layoutChildren(ListView.java:1734)
// at android.widget.ListView.setSelectionInt(ListView.java:2157)
// at android.widget.AbsListView.resurrectSelection(AbsListView.java:5608)
// at android.widget.AbsListView.resurrectSelectionIfNeeded(AbsListView.java:5497)
// at android.widget.ListView.commonKey(ListView.java:2319)
// at android.widget.ListView.onKeyDown(ListView.java:2243)
// at android.view.KeyEvent.dispatch(KeyEvent.java:2719)
// at android.view.View.dispatchKeyEvent(View.java:7147)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1365)
// at android.widget.ListView.dispatchKeyEvent(ListView.java:2228)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.support.v4.view.ViewPager.dispatchKeyEvent(Unknown Source)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at com.android.internal.policy.impl.PhoneWindow$DecorView.superDispatchKeyEvent(PhoneWindow.java:2013)
// at com.android.internal.policy.impl.PhoneWindow.superDispatchKeyEvent(PhoneWindow.java:1490)
// at android.app.Activity.dispatchKeyEvent(Activity.java:2414)
// at com.android.internal.policy.impl.PhoneWindow$DecorView.dispatchKeyEvent(PhoneWindow.java:1940)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.widget.TabHost.dispatchKeyEvent(TabHost.java:298)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at android.view.ViewGroup.dispatchKeyEvent(ViewGroup.java:1369)
// at com.android.internal.policy.impl.PhoneWindow$DecorView.superDispatchKeyEvent(PhoneWindow.java:2013)
// at com.android.internal.policy.impl.PhoneWindow.superDispatchKeyEvent(PhoneWindow.java:1490)
// at android.app.Activity.dispatchKeyEvent(Activity.java:2414)
// at com.android.internal.policy.impl.PhoneWindow$DecorView.dispatchKeyEvent(PhoneWindow.java:1940)
// at android.view.ViewRootImpl.deliverKeyEventPostIme(ViewRootImpl.java:4093)
// at android.view.ViewRootImpl.handleImeFinishedEvent(ViewRootImpl.java:4063)
// at android.view.ViewRootImpl$ViewRootHandler.handleMessage(ViewRootImpl.java:3232)
// at android.os.Handler.dispatchMessage(Handler.java:99)
// at android.os.Looper.loop(Looper.java:155)
// at android.app.ActivityThread.main(ActivityThread.java:5536)
// at java.lang.reflect.Method.invokeNative(Native Method)
// at java.lang.reflect.Method.invoke(Method.java:511)
// at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:1074)
// at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:841)
// at dalvik.system.NativeStart.main(Native Method)
posted @
2013-06-06 09:17 Terry Zou 阅读(1275) |
评论 (0) |
编辑 收藏----------------------------------------------一.WEB项目的执行流程---------------------------------
1.web项目的运行流程大致如下：
启动tomcat，先到web.xml里面查看<context-param><listener><filter><servlet>等等几个tag，查看里面的配置，查找相应的配置文件。
如下列文件所示：
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="
http://www.w3.org/2001/XMLSchema-instance" xmlns="
http://java.sun.com/xml/ns/javaee" xmlns:web="
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="
http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>SpringMVC12</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:config/springAnnotation-*.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:config/springAnnotation-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<!-- encoding filter for jsp page -->
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<filter>
<filter-name>openSession</filter-name>
<filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>openSession</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
首先查看那几个标签，找到对应的配置文件，如<context-param>中配置的classpath*:config/springAnnotation-*.xml。
---------------------------------------2.到配置文件查看相关信息----------------------------------------------
（1）<context-param>里的classpath*:config/springAnnotation-*.xml，即在config目录下匹配springAnnotation-*.xml的文件
（1.1）查看springAnnotation-core.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd" [
<!ENTITY contextInclude SYSTEM "org/springframework/web/context/WEB-INF/contextInclude.xml">
]>
<beans>
<import resource="classpath*:com/zyh/web/controller/spring/springAnnotation-import.xml"/>
</beans>
对应的路径如下com/zyh/web/controller/spring/springAnnotation-import.xml
（1.2）查看springAnnotation-import.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd" [
<!ENTITY contextInclude SYSTEM "org/springframework/web/context/WEB-INF/contextInclude.xml">
]>
<beans>
<bean id="userDao" class="com.zyh.web.controller.dao.UserDAO">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean id="userManagerBase" class="com.zyh.web.controller.service.UserManager">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userManager" parent="transactionBese">
<property name="target" ref="userManagerBase"></property>
</bean>
</beans>
对应关于就已经配置在容器里面了。
（2.1）查看springAnnotation-hibernate.xml（配置数据源，sessionFactory，和事物）
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd" [
<!ENTITY contextInclude SYSTEM "org/springframework/web/context/WEB-INF/contextInclude.xml">
]>
<beans>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost/test1?useUnicode=true"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hiberante.format_sql">true</prop>
</props>
</property>
<property name="configLocations">
<list>
<value>
classpath*:com/zyh/web/controller/hibernate/hibernate.cfg.test.xml
</value>
</list>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean id="transactionBese" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" lazy-init="true" abstract="true">
<property name="transactionManager" ref="transactionManager"></property>
<property name="transactionAttributes">
<props>
<prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="insert*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="modify*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="delete*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="get*">PROPAGATION_NEVER</prop>
</props>
</property>
</bean>
</beans>
配置的对应的 classpath*:com/zyh/web/controller/hibernate/hibernate.cfg.test.xml
（3）springAnnotation-servlet.xml，内容如下
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<!-- 注解扫描包 -->
<context:component-scan base-package="com.zyh.web.controller" />
<!-- 开启注解 -->
<mvc:annotation-driven/>
<!-- <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"></bean> -->
<!-- 静态资源访问 -->
<mvc:resources location="/img/" mapping="/img/**"/>
<mvc:resources location="/js/" mapping="/js/**"/>
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="defaultEncoding" value="utf-8" />
<property name="maxUploadSize" value="10485760000" />
<property name="maxInMemorySize" value="40960" />
</bean>
</beans>
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:mvc="http://www.springframework.org/schema/mvc"
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-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<!-- 注解扫描包 -->
<context:component-scan base-package="com.zyh.web.controller" />
<!-- 开启注解 -->
<mvc:annotation-driven/>
<!-- <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"></bean> -->
<!-- 静态资源访问 -->
<mvc:resources location="/img/" mapping="/img/**"/>
<mvc:resources location="/js/" mapping="/js/**"/>
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="defaultEncoding" value="utf-8" />
<property name="maxUploadSize" value="10485760000" />
<property name="maxInMemorySize" value="40960" />
</bean>
</beans>
springAnnotation-hibernate.xml<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd" [
<!ENTITY contextInclude SYSTEM "org/springframework/web/context/WEB-INF/contextInclude.xml">
]>
<beans>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost/test1?useUnicode=true"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hiberante.format_sql">true</prop>
</props>
</property>
<property name="configLocations">
<list>
<value>
classpath*:com/zyh/web/controller/hibernate/hibernate.cfg.test.xml
</value>
</list>
</property>
</bean>
<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean id="transactionBese" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" lazy-init="true" abstract="true">
<property name="transactionManager" ref="transactionManager"></property>
<property name="transactionAttributes">
<props>
<prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="update*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="insert*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="modify*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="delete*">PROPAGATION_REQUIRED,-Exception</prop>
<prop key="get*">PROPAGATION_NEVER</prop>
</props>
</property>
</bean>
</beans>
这个写的有点乱，理清思路，其实很简单，就是配置spring容器,里面扫描了所有的bean及一些依赖关系，hibernate配置数据源建立数据库连接，SessionFactory用于管理数据库，还有就是Springmvc用于控制视图与后台之间的页面转向，传递数据，发送请求。
配置工作就到此结束，然后就是写bean,dao,service,control与联系配置文件的对应关系，实际开发中当然不会把配置文件都写好才来写java代码。我的做法是同时进行，漏了就相应的加上。
-----------------------------------------------------------3对应的实现--------------------------------------
3.1 为了简单，我们建立一个单表的添删改查，就一个对象吧User，对应的表T_User,里面有userName和age两个属性，当然还要建立一个主键id,如下列代码所示:
com.zyh.web.controller.entity.User
package com.zyh.web.controller.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="T_USER")
public class User {
@GeneratedValue(generator = "system-uuid")
@GenericGenerator(name = "system-uuid", strategy = "uuid")
@Column(length=32)
@Id
private String id;
@Column(length=32)
private String userName;
@Column(length=32)
private String age;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
3.2 dao层结构如下：接口IUserDAO与实现类UserDAO，我们实现添删改查，查询包括一个User和所以User
com.zyh.web.controller.dao.IUserDAO
package com.zyh.web.controller.dao;
import java.util.List;
import com.zyh.web.controller.entity.User;
public interface IUserDAO {
public void addUser(User user);
public List<User> getAllUser();
public User getUser(String id);
public boolean delUser(String id);
public boolean updateUser(User user);
}
实现类UserDAO:
package com.zyh.web.controller.dao;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.SessionFactory;
import com.zyh.web.controller.entity.User;
public class UserDAO implements IUserDAO {
private SessionFactory sessionFactory;
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
@Override
public void addUser(User user) {
// TODO Auto-generated method stub
sessionFactory.getCurrentSession().save(user);
}
@Override
public List<User> getAllUser() {
// TODO Auto-generated method stub
String hql = "from User";
Query query = sessionFactory.getCurrentSession().createQuery(hql);
return query.list();
}
@Override
public User getUser(String id) {
// TODO Auto-generated method stub
String hql = "from User u where u.id=?";
Query query = sessionFactory.getCurrentSession().createQuery(hql);
query.setString(0, id);
return (User) query.uniqueResult();
}
@Override
public boolean delUser(String id) {
// TODO Auto-generated method stub
String hql = "delete User u where u.id=?";
Query query = sessionFactory.getCurrentSession().createQuery(hql);
query.setString(0, id);
return (query.executeUpdate()>0);
}
@Override
public boolean updateUser(User user) {
// TODO Auto-generated method stub
String hql = "update User u set u.userName=?,u.age=? where u.id=?";
Query query = sessionFactory.getCurrentSession().createQuery(hql);
query.setString(0, user.getUserName());
query.setString(1, user.getAge());
query.setString(2, user.getId());
return (query.executeUpdate()>0);
}
}
3.3 service层结构如下：接口IUserManager与实现类UserManager，我们实现添删改查，查询包括一个User和所以User
com.zyh.web.controller.service.IUserManager
package com.zyh.web.controller.service;
import java.util.List;
import com.zyh.web.controller.entity.User;
public interface IUserManager {
public void addUser(User user);
public List<User> getAllUser();
public boolean delUser(String id);
public User getUser(String id);
public boolean updateUser(User user);
}
实现类UserManager.java
package com.zyh.web.controller.service;
import java.util.List;
import com.zyh.web.controller.dao.IUserDAO;
import com.zyh.web.controller.entity.User;
public class UserManager implements IUserManager {
private IUserDAO userDao;
public void setUserDao(IUserDAO userDao) {
this.userDao = userDao;
}
@Override
public void addUser(User user) {
// TODO Auto-generated method stub
userDao.addUser(user);
}
@Override
public List<User> getAllUser() {
// TODO Auto-generated method stub
return userDao.getAllUser();
}
@Override
public boolean delUser(String id) {
// TODO Auto-generated method stub
return userDao.delUser(id);
}
@Override
public User getUser(String id) {
// TODO Auto-generated method stub
return userDao.getUser(id);
}
@Override
public boolean updateUser(User user) {
// TODO Auto-generated method stub
return userDao.updateUser(user);
}
}
4.Control层结构如下：实现类UserController.java，代码如下：
package com.zyh.web.controller;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.zyh.web.controller.entity.User;
import com.zyh.web.controller.service.IUserManager;
@Controller
@RequestMapping("/user")
public class UserController {
@Resource(name="userManager")
private IUserManager userManager;
@RequestMapping("/toAddUser")
public String toAddUser(){
return "/addUser";
}
@RequestMapping("/addUser")
public String addUser(User user){
userManager.addUser(user);
return "redirect:/user/getAllUser";
}
@RequestMapping("/getAllUser")
public String getAllUser(HttpServletRequest request){
List<User> user = userManager.getAllUser();
request.setAttribute("user", user);
return "/userManager";
}
@RequestMapping("/delUser")
public void delUser(String id,HttpServletResponse response){
String result = "{\"result\":\"error\"}";
if(userManager.delUser(id)){
result = "{\"result\":\"success\"}";
}
response.setContentType("application/json");
PrintWriter pw;
try {
pw = response.getWriter();
pw.write(result);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@RequestMapping("/getUser")
public String getUser(String id,HttpServletRequest request){
User user = userManager.getUser(id);
request.setAttribute("user", user);
return "editUser";
}
@RequestMapping("/updateUser")
public String updateUser(User user,HttpServletRequest request){
if(userManager.updateUser(user)){
userManager.getUser(user.getId());
request.setAttribute("user", user);
return "/editUser";
}else{
return "/error";
}
}
}
package com.zyh.web.controller;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.zyh.web.controller.entity.User;
import com.zyh.web.controller.service.IUserManager;
@Controller
@RequestMapping("/user")
public class UserController {
@Resource(name="userManager")
private IUserManager userManager;
@RequestMapping("/toAddUser")
public String toAddUser(){
return "/addUser";
}
@RequestMapping("/addUser")
public String addUser(User user){
userManager.addUser(user);
return "redirect:/user/getAllUser";
}
@RequestMapping("/getAllUser")
public String getAllUser(HttpServletRequest request){
List<User> user = userManager.getAllUser();
request.setAttribute("user", user);
return "/userManager";
}
@RequestMapping("/delUser")
public void delUser(String id,HttpServletResponse response){
String result = "{\"result\":\"error\"}";
if(userManager.delUser(id)){
result = "{\"result\":\"success\"}";
}
response.setContentType("application/json");
PrintWriter pw;
try {
pw = response.getWriter();
pw.write(result);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@RequestMapping("/getUser")
public String getUser(String id,HttpServletRequest request){
User user = userManager.getUser(id);
request.setAttribute("user", user);
return "editUser";
}
@RequestMapping("/updateUser")
public String updateUser(User user,HttpServletRequest request){
if(userManager.updateUser(user)){
userManager.getUser(user.getId());
request.setAttribute("user", user);
return "/editUser";
}else{
return "/error";
}
}
}
package com.zyh.web.controller.service;
import java.util.List;
import com.zyh.web.controller.dao.IUserDAO;
import com.zyh.web.controller.entity.User;
public class UserManager implements IUserManager {
private IUserDAO userDao;
public void setUserDao(IUserDAO userDao) {
this.userDao = userDao;
}
@Override
public void addUser(User user) {
// TODO Auto-generated method stub
userDao.addUser(user);
}
@Override
public List<User> getAllUser() {
// TODO Auto-generated method stub
return userDao.getAllUser();
}
@Override
public boolean delUser(String id) {
// TODO Auto-generated method stub
return userDao.delUser(id);
}
@Override
public User getUser(String id) {
// TODO Auto-generated method stub
return userDao.getUser(id);
}
@Override
public boolean updateUser(User user) {
// TODO Auto-generated method stub
return userDao.updateUser(user);
}
}
package com.zyh.web.controller.service;
import java.util.List;
import com.zyh.web.controller.entity.User;
public interface IUserManager {
public void addUser(User user);
public List<User> getAllUser();
public boolean delUser(String id);
public User getUser(String id);
public boolean updateUser(User user);
}
3.2 dao层结构如下：接口IUserDAO与实现类UserDAO，我们实现添删改查，查询包括一个User和所以User
com.zyh.web.controller.dao.IUserDAO
package com.zyh.web.controller.dao;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.SessionFactory;
import com.zyh.web.controller.entity.User;
public class UserDAO implements IUserDAO {
private SessionFactory sessionFactory;
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
@Override
public void addUser(User user) {
// TODO Auto-generated method stub
sessionFactory.getCurrentSession().save(user);
}
@Override
public List<User> getAllUser() {
// TODO Auto-generated method stub
String hql = "from User";
Query query = sessionFactory.getCurrentSession().createQuery(hql);
return query.list();
}
@Override
public User getUser(String id) {
// TODO Auto-generated method stub
String hql = "from User u where u.id=?";
Query query = sessionFactory.getCurrentSession().createQuery(hql);
query.setString(0, id);
return (User) query.uniqueResult();
}
@Override
public boolean delUser(String id) {
// TODO Auto-generated method stub
String hql = "delete User u where u.id=?";
Query query = sessionFactory.getCurrentSession().createQuery(hql);
query.setString(0, id);
return (query.executeUpdate()>0);
}
@Override
public boolean updateUser(User user) {
// TODO Auto-generated method stub
String hql = "update User u set u.userName=?,u.age=? where u.id=?";
Query query = sessionFactory.getCurrentSession().createQuery(hql);
query.setString(0, user.getUserName());
query.setString(1, user.getAge());
query.setString(2, user.getId());
return (query.executeUpdate()>0);
}
}
package com.zyh.web.controller.dao;
import java.util.List;
import com.zyh.web.controller.entity.User;
public interface IUserDAO {
public void addUser(User user);
public List<User> getAllUser();
public User getUser(String id);
public boolean delUser(String id);
public boolean updateUser(User user);
}
package com.zyh.web.controller.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="T_USER")
public class User {
@GeneratedValue(generator = "system-uuid")
@GenericGenerator(name = "system-uuid", strategy = "uuid")
@Column(length=32)
@Id
private String id;
@Column(length=32)
private String userName;
@Column(length=32)
private String age;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
posted @
2013-06-01 10:49 Terry Zou 阅读(4143) |
评论 (0) |
编辑 收藏
public static Bitmap getPicFromBytes(byte[] bytes, BitmapFactory.Options opts) {
if (bytes != null)
if (opts != null)
return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, opts);
else
return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
return null;
}
这里我们主要来介绍一个BitmapFactory.Options这个类
BitmapFactory.Options这个类的详解如下：
public Bitmap | inBitmap | If set, decode methods that take the Options object will attempt to reuse this bitmap when loading content. |
public int | inDensity | The pixel density to use for the bitmap. |
public boolean | inDither | If dither is true, the decoder will attempt to dither the decoded image. |
public boolean | inInputShareable | This field works in conjuction with inPurgeable. |
public boolean | inJustDecodeBounds | If set to true, the decoder will return null (no bitmap), but the out… |
public boolean | inMutable | If set, decode methods will always return a mutable Bitmap instead of an immutable one. |
public boolean | inPreferQualityOverSpeed | If inPreferQualityOverSpeed is set to true, the decoder will try to decode the reconstructed image to a higher quality even at the expense of the decoding speed. |
publicBitmap.Config | inPreferredConfig | If this is non-null, the decoder will try to decode into this internal configuration. |
public boolean | inPurgeable | If this is set to true, then the resulting bitmap will allocate its pixels such that they can be purged if the system needs to reclaim memory. |
public int | inSampleSize | If set to a value > 1, requests the decoder to subsample the original image, returning a smaller image to save memory. |
public boolean | inScaled | When this flag is set, if inDensity and inTargetDensity are not 0, the bitmap will be scaled to match inTargetDensity when loaded, rather than relying on the graphics system scaling it each time it is drawn to a Canvas. |
public int | inScreenDensity | The pixel density of the actual screen that is being used. |
public int | inTargetDensity | The pixel density of the destination this bitmap will be drawn to. |
public byte[] | inTempStorage | Temp storage to use for decoding. |
public boolean | mCancel | Flag to indicate that cancel has been called on this object. |
public int | outHeight | The resulting height of the bitmap, set independent of the state of inJustDecodeBounds. |
public String | outMimeType | If known, this string is set to the mimetype of the decoded image. |
public int | outWidth | The resulting width of the bitmap, set independent of the state of inJustDecodeBounds. |
这个表格是从android sdk文档里摘出来的，简单看一下说明就明白是什么意思了。
下面我们回到我们的主题上来：怎样获取图片的大小？
思路很简单：
首先我们把这个图片转成Bitmap，然后再利用Bitmap的getWidth()和getHeight()方法就可以取到图片的宽高了。
新问题又来了，在通过BitmapFactory.decodeFile(String path)方法将突破转成Bitmap时，遇到大一些的图片，我们经常会遇到OOM(Out Of Memory)的问题。怎么避免它呢？
这就用到了我们上面提到的BitmapFactory.Options这个类。
BitmapFactory.Options这个类，有一个字段叫做 inJustDecodeBounds 。SDK中对这个成员的说明是这样的：
If set to true, the decoder will return null (no bitmap), but the out…
也就是说，如果我们把它设为true，那么BitmapFactory.decodeFile(String path, Options opt)并不会真的返回一个Bitmap给你，它仅仅会把它的宽，高取回来给你，这样就不会占用太多的内存，也就不会那么频繁的发生OOM了。
示例代码如下：
- BitmapFactory.Options options = new BitmapFactory.Options();
- options.inJustDecodeBounds = true;
- Bitmap bmp = BitmapFactory.decodeFile(path, options);
- /* 这里返回的bmp是null */
复制代码
这段代码之后，options.outWidth 和 options.outHeight就是我们想要的宽和高了。
有了宽，高的信息，我们怎样在图片不变形的情况下获取到图片指定大小的缩略图呢？
比如我们需要在图片不变形的前提下得到宽度为200的缩略图。
那么我们需要先计算一下缩放之后，图片的高度是多少
- /* 计算得到图片的高度 */
- /* 这里需要主意，如果你需要更高的精度来保证图片不变形的话，需要自己进行一下数学运算 */
- int height = options.outHeight * 200 / options.outWidth;
- options.outWidth = 200；
- options.outHeight = height;
- /* 这样才能真正的返回一个Bitmap给你 */
- options.inJustDecodeBounds = false;
- Bitmap bmp = BitmapFactory.decodeFile(path, options);
- image.setImageBitmap(bmp);
复制代码
这样虽然我们可以得到我们期望大小的ImageView
但是在执行BitmapFactory.decodeFile(path, options);时，并没有节约内存。要想节约内存，还需要用到BitmapFactory.Options这个类里的 inSampleSize 这个成员变量。
我们可以根据图片实际的宽高和我们期望的宽高来计算得到这个值。
- inSampleSize = options.outWidth / 200;
另外，为了节约内存我们还可以使用下面的几个字段：
- options.inPreferredConfig = Bitmap.Config.ARGB_4444; // 默认是Bitmap.Config.ARGB_8888
- /* 下面两个字段需要组合使用 */
- options.inPurgeable = true;
- options.inInputShareable = true;
posted @
2013-05-29 11:36 Terry Zou 阅读(2819) |
评论 (0) |
编辑 收藏
1） 用第一种方式的弊端：
a. 会将原来系统中的对应的apk覆盖掉，所以，最好先备份出来一份，用如下命令：
adb pull /system/app/xxxx.apk /home/
b. 有时候，会出现如下形式的错误信息：
failed to copy '/home/SoundRecorder.apk' to '/system/app/SoundRecorder.apk': Read-only file system
很明显，/system/app目录是只读的，不能将文件push到这个目录下。
解决方法，用直接安装的方式进行安装，如下：
adb install -r /home/SoundRecorder.apk //注： -r 表示强制安装
这样，会将应用程序安装到 /data/local/tmp/ 目录下。
2) 用第二种方式的话，设备中不回保存apk文件，如果以后删除了这个应用，就要重新找到对应的apk，才能安装。
posted @
2013-05-29 09:21 Terry Zou 阅读(363) |
评论 (0) |
编辑 收藏<context-param>的作用:
web.xml的配置中<context-param>配置作用
1. 启动一个WEB项目的时候,容器(如:Tomcat)会去读它的配置文件web.xml.读两个节点: <listener></listener> 和 <context-param></context-param>
2.紧接着,容器创建一个ServletContext(上下文),这个WEB项目所有部分都将共享这个上下文.
3.容器将<context-param></context-param>转化为键值对,并交给ServletContext.
4.容器创建<listener></listener>中的类实例,即创建监听.
5.在监听中会有contextInitialized(ServletContextEvent args)初始化方法,在这个方法中获得ServletContext = ServletContextEvent.getServletContext();
context-param的值 = ServletContext.getInitParameter("context-param的键");
6.得到这个context-param的值之后,你就可以做一些操作了.注意,这个时候你的WEB项目还没有完全启动完成.这个动作会比所有的Servlet都要早.
换句话说,这个时候,你对<context-param>中的键值做的操作,将在你的WEB项目完全启动之前被执行.
7.举例.你可能想在项目启动之前就打开数据库.
那么这里就可以在<context-param>中设置数据库的连接方式,在监听类中初始化数据库的连接.
8.这个监听是自己写的一个类,除了初始化方法,它还有销毁方法.用于关闭应用前释放资源.比如说数据库连接的关闭.
如:
<!-- 加载spring的配置文件 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml,/WEB-INF/act
ion-servlet.xml,/WEB-INF/jason-servlet.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
又如: --->自定义context-param,且自定义listener来获取这些信息
<context-param>
<param-name>urlrewrite</param-name>
<param-value>false</param-value>
</context-param>
<context-param>
<param-name>cluster</param-name>
<param-value>false</param-value>
</context-param>
<context-param>
<param-name>servletmapping</param-name>
<param-value>*.bbscs</param-value>
</context-param>
<context-param>
<param-name>poststoragemode</param-name>
<param-value>1</param-value>
</context-param>
<listener>
<listener-class>com.laoer.bbscs.web.servlet.SysListener</listener-class>
</listener>
public class SysListener extends HttpServlet implements ServletContextListener {
private static final Log logger = LogFactory.getLog(SysListener.class);
public void contextDestroyed(ServletContextEvent sce) {
//用于在容器关闭时,操作
}
//用于在容器开启时,操作
public void contextInitialized(ServletContextEvent sce) {
String rootpath = sce.getServletContext().getRealPath("/");
System.out.println("-------------rootPath:"+rootpath);
if (rootpath != null) {
rootpath = rootpath.replaceAll("
\\\\", "/");
} else {
rootpath = "/";
}
if (!rootpath.endsWith("/")) {
rootpath = rootpath + "/";
}
Constant.ROOTPATH = rootpath;
logger.info("Application Run Path:" + rootpath);
String urlrewrtie =
sce.getServletContext().getInitParameter("urlrewrite"); boolean burlrewrtie = false;
if (urlrewrtie != null) {
burlrewrtie = Boolean.parseBoolean(urlrewrtie);
}
Constant.USE_URL_REWRITE = burlrewrtie;
logger.info("Use Urlrewrite:" + burlrewrtie);
其它略之....
}
}
/*最终输出
-------------rootPath:D:\tomcat_bbs\webapps\BBSCS_8_0_3\
2009-06-09 21:51:46,526 [com.laoer.bbscs.web.servlet.SysListener]-[INFO]
Application Run Path:D:/tomcat_bbs/webapps/BBSCS_8_0_3/
2009-06-09 21:51:46,526 [com.laoer.bbscs.web.servlet.SysListener]-[INFO]
Use Urlrewrite:true
2009-06-09 21:51:46,526 [com.laoer.bbscs.web.servlet.SysListener]-[INFO]
Use Cluster:false
2009-06-09 21:51:46,526 [com.laoer.bbscs.web.servlet.SysListener]-[INFO]
SERVLET MAPPING:*.bbscs
2009-06-09 21:51:46,573 [com.laoer.bbscs.web.servlet.SysListener]-[INFO]
Post Storage Mode:1
*/
context-param和init-param区别
web.xml里面可以定义两种参数：
(1)application范围内的参数，存放在servletcontext中，在web.xml中配置如下：
<context-param>
<param-name>context/param</param-name>
<param-value>avalible during application</param-value>
</context-param>
(2)servlet范围内的参数，只能在servlet的init()方法中取得，在web.xml中配置如下：
<servlet>
<servlet-name>MainServlet</servlet-name>
<servlet-class>com.wes.controller.MainServlet</servlet-class>
<init-param>
<param-name>param1</param-name>
<param-value>avalible in servlet init()</param-value>
</init-param>
<load-on-startup>0</load-on-startup>
</servlet>
在servlet中可以通过代码分别取用：
package com.wes.controller;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
public class MainServlet extends HttpServlet ...{
public MainServlet() ...{
super();
}
public void init() throws ServletException ...{
System.out.println("下面的两个参数param1是在servlet中存放的");
System.out.println(this.getInitParameter("param1"));
System.out.println("下面的参数是存放在servletcontext中的");
System.out.println(getServletContext().getInitParameter("context/param"));
}
}
第一种参数在servlet里面可以通过getServletContext().getInitParameter("context/param")得到
第二种参数只能在servlet的init()方法中通过this.getInitParameter("param1")取得.
文章来源自：
http://www.cnblogs.com/hzj-/articles/1689836.html
posted @
2013-05-27 11:45 Terry Zou 阅读(169) |
评论 (0) |
编辑 收藏
回调函数其实用起来比较简单，主要有三个部分
第一部分：定义一个接口用于回调；
如下所示：
public interface CallBackInterface {
public void doSome();
public void exectueMethod();
}
第二部分：在一个类里面把它当做参数并用到该参数
如下所示：
public class MethodB {
public double getTime(CallBackInterface callBack){
long start = System.currentTimeMillis();
callBack.exectueMethod();
long end = System.currentTimeMillis();
System.out.println("cost time="+(end-start));
return end-start;
}
}
第三部分：在另外一个类里面调用到getTime方法并实现回调函数
如下所示:
public class MethodA {
public static void main(String[] args) {
MethodB b = new MethodB();
double d = b.getTime(new CallBackInterface() {
@Override
public void exectueMethod() {
// TODO Auto-generated method stub
new MethodA().testMethod();
}
@Override
public void doSome() {
// TODO Auto-generated method stub
}
});
System.out.println("d="+d);
}
public void testMethod(){
for(int i=0;i<10000;i++)
System.out.print("");
}
}
输出结果：
cost time=31
d=31.0
理解“回调函数”
所谓回调，就是客户程序CLIENT调用服务程序SERVER中的某个函数SA，然后SERVER又在某个时候反过来调用CLIENT中的某个函数CB，对于CLIENT来说，这个CB便叫做回调函数。例如Win32下的窗口过程函数就是一个典型的回调函数。
一般说来，CLIENT不会自己调用CB，CLIENT提供CB的目的就是让SERVER来调用它，而且是CLIENT不得不提供。由于SERVER并不知道CLIENT提供的CB叫甚名谁，所以SERVER会约定CB的接口规范（函数原型），然后由CLIENT提前通过SERVER的一个函数R告诉SERVER自己将要使用CB函数，这个过程称为回调函数的注册，R称为注册函数。Web SERVERerviCliente以及Java的RMI都用到回调机制，可以访问远程服务器程序。
下面举个通俗的例子：
某天，我打电话向你请教问题，当然是个难题，:)，你一时想不出解决方法，我又不能拿着电话在那里傻等，于是我们约定：等你想出办法后打手机通知我，这样，我就挂掉电话办其它事情去了。过了XX分钟，我的手机响了，你兴高采烈的说问题已经搞定，应该如此这般处理。故事到此结束。这个例子说明了“异步＋回调”的编程模式。其中，你后来打手机告诉我结果便是一个“回调”过程；我的手机号码必须在以前告诉你，这便是注册回调函数；我的手机号码应该有效并且手机能够接收到你的呼叫，这是回调函数必须符合接口规范。
通过上面个人感觉到回调函数更多的应用就是结合异步。比如：ajax中jServer通过组件和服务器的异步通信。
什么是回调函数
精妙比喻:回调函数还真有点像您随身带的BP机：告诉别人号码，在它有事情时Call您
回调用于层间协作，上层将本层函数安装在下层，这个函数就是回调，而下层在一定条件下触发回调，例如作为一个驱动，是一个底层，他在收到一个数据时，除了完成本层的处理工作外，还将进行回调，将这个数据交给上层应用层来做进一步处理，这在分层的数据通信中很普遍。
其实回调和API非常接近，他们的共性都是跨层调用的函数。但区别是API是低层提供给高层的调用，一般这个函数对高层都是已知的；而回调正好相反，他是高层提供给底层的调用，对于低层他是未知的，必须由高层进行安装，这个安装函数其实就是一个低层提供的API，安装后低层不知道这个回调的名字，但它通过一个函数指针来保存这个回调，在需要调用时，只需引用这个函数指针和相关的参数指针。
其实：回调就是该函数写在高层，低层通过一个函数指针保存这个函数，在某个事件的触发下，低层通过该函数指针调用高层那个函数。
【参考】
http://blog.csdn.net/sweetwxh/article/details/2067139
http://liutiemeng.blog.51cto.com/120361/18874
http://kidult.iteye.com/blog/148982
public static void main(String[] args) {
MethodB b = new MethodB();
double d = b.getTime(new CallBackInterface() {
@Override
public void exectueMethod() {
// TODO Auto-generated method stub
new MethodA().testMethod();
}
@Override
public void doSome() {
// TODO Auto-generated method stub
}
});
System.out.println("d="+d);
}
public void testMethod(){
for(int i=0;i<10000;i++)
System.out.print("");
}
posted @
2013-05-27 11:13 Terry Zou 阅读(148) |
评论 (0) |
编辑 收藏
摘要: --------------------------------------------------(一)androidpn-server服务器端启动的理解和分析-----------------------------------------------
在Androidpn的底层主要采用的两大框架mina和openfire两大框架，其中mi...
阅读全文
posted @
2013-05-24 17:05 Terry Zou 阅读(5200) |
评论 (1) |
编辑 收藏
这个方法的含义说明：
这个方法的意思就是在jvm中增加一个关闭的钩子，当jvm关闭的时候，会执行系统中已经设置的所有通过方法addShutdownHook添加的钩子，当系统执行完这些钩子后，jvm才会关闭。所以这些钩子可以在jvm关闭的时候进行内存清理、对象销毁等操作。
测试类如下：
- public class RunTimeTest {
-
-
-
- public static void main(String[] args) {
- Thread thread1 = new Thread() {
- public void run() {
- System.out.println("thread1...");
- }
- };
- Thread thread2 = new Thread() {
- public void run() {
- System.out.println("thread2...");
- }
- };
- Thread shutdownThread = new Thread() {
- public void run() {
- System.out.println("shutdownThread...");
- }
- };
- Runtime.getRuntime().addShutdownHook(shutdownThread);
- thread1.start();
- thread2.start();
- }
- }
打印结果为：
thread2...
thread1...
shutdownThread...
或者：
thread2...
thread1...
shutdownThread...
结论：
无论是先打印thread1还是thread2，shutdownThread 线程都是最后执行的（因为这个线程是在jvm执行关闭前才会执行）。
posted @
2013-05-23 16:34 Terry Zou 阅读(230) |
评论 (0) |
编辑 收藏对Java程序来说，只要还有一个前台线程在运行，这个进程就不会结束，如果一个进程中只有后台线程在运行，这个进程就会结束。前台线程是相对后台线程而言的，前面所介绍的线程都是前台线程。那么什么样的线程是后台线程呢？如果某个线程对象在启动（调用start()方法）之前调用了setDaemon(true)方法，这个线程就变成了后台线程。下面来看一下进程中只有后台线程在运行的情况，如下所示：
范例：ThreadDaemon.java
01 public class ThreadDaemon
02 {
03 public static void main(String args[])
04 {
05 ThreadTest t = new ThreadTest() ;
06 Thread tt = new Thread(t) ;
07 tt.setDaemon(true) ; // 设置后台运行
08 tt.start();
09 }
10 }
11
12 class ThreadTest implements Runnable
13 {
14 public void run()
15 {
16 while(true)
17 {
18 System.out.println(Thread.currentThread().getName()+"is running.");
19 }
20 }
21 }
从上面的程序和运行结果（图9-4）上，可以看到：虽然创建了一个无限循环的线程，但因为它是后台线程，整个进程在主线程结束时就随之终止运行了。这验证了
进程中只有后台线程运行时，进程就会结束的说法。
posted @
2013-05-23 09:09 Terry Zou 阅读(456) |
评论 (0) |
编辑 收藏1、PendingIntent作用
根据字面意思就知道是延迟的intent，主要用来在某个事件完成后执行特定的Action。PendingIntent包含了Intent及Context，所以就算Intent所属程序结束，PendingIntent依然有效，可以在其他程序中使用。
常用在通知栏及短信发送系统中。
PendingIntent一般作为参数传给某个实例，在该实例完成某个操作后自动执行PendingIntent上的Action，也可以通过PendingIntent的send函数手动执行，并可以在send函数中设置OnFinished表示send成功后执行的动作。
2.举例（通知栏应用）
界面A 定义一个notification
NotificationManager nm = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
int icon = R.drawable.notification;
long when = System.currentTimeMillis()+2000;
Notification n = new Notification(icon,"标题",when);
n.defaults = Notification.DEFAULT_SOUND;
n.flags |= Notification.FLAG_AUTO_CANCEL;
Intent intent = new Intent(this,B.class);
PendingIntent pi = new PendingIntent.getActivity(this,0,intent,PendingIntent.FLAG_CANCEL_CURRENT);
n.setLatesEventInfo(this,"通知栏demo提醒title","通知栏demo提醒text",pi);
nm.notify(0,n);
B.界面Intent intent = getIntent();
String title = intent.getStringExtra("title");
效果，当A界面显示，生成一个按钮，点击该按钮生成如上所示的通知栏，点击通知栏，则显示B界面，参数title为所显示的值。
3、Intent和PendingIntent的区别a. Intent是立即使用的，而PendingIntent可以等到事件发生后触发，PendingIntent可以cancel
b. Intent在程序结束后即终止，而PendingIntent在程序结束后依然有效
c. PendingIntent自带Context，而Intent需要在某个Context内运行
d. Intent在原task中运行，PendingIntent在新的task中运行
posted @
2013-05-22 15:34 Terry Zou 阅读(240) |
评论 (0) |
编辑 收藏PhoneStateListener
1.对特定的电话状态的监听，包括服务的状态、信号强度、消息等待指示（语音信箱）、通话转移、呼叫状态、设备单元位置、数据连接状态、数据流量方向。一些电话信息受权限保护，应用程序不会收到受保护的信息的更新，除非在manifest文件中有适当的权限声明。凡申请许可，有适当的LISTEN_标志。
2.对监听的话做处理
Handler mHandler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case LISTEN_SERVICE_STATE:/*Listen for changes to the network service state (cellular).对网络服务状态监听*/
PhoneStateListener.this.onServiceStateChanged((ServiceState)msg.obj);
break;
case LISTEN_SIGNAL_STRENGTH:/*Listen for changes to the network signal strength (cellular).对网络信号强度变化监听*/
PhoneStateListener.this.onSignalStrengthChanged(msg.arg1);
break;
case LISTEN_MESSAGE_WAITING_INDICATOR:/*Listen for changes to the message-waiting indicator.对消息等待指示的变化监听*/
PhoneStateListener.this.onMessageWaitingIndicatorChanged(msg.arg1 != 0);
break;
case LISTEN_CALL_FORWARDING_INDICATOR:/*Listen for changes to the call-forwarding indicator.对通话转移指示的变化监听*/
PhoneStateListener.this.onCallForwardingIndicatorChanged(msg.arg1 != 0);
break;
case LISTEN_CELL_LOCATION:/*Listen for changes to the device's cell location. Note that this will result in frequent callbacks to the listener.对设备单元位置的变化监听，这会导致频繁的监听回调。*/
PhoneStateListener.this.onCellLocationChanged((CellLocation)msg.obj);
break;
case LISTEN_CALL_STATE:/*Listen for changes to the device call state.对设备呼叫状态的变化监听。*/
PhoneStateListener.this.onCallStateChanged(msg.arg1, (String)msg.obj);
break;
case LISTEN_DATA_CONNECTION_STATE:/*Listen for changes to the data connection state (cellular).对数据连接状态的变化监听。*/
PhoneStateListener.this.onDataConnectionStateChanged(msg.arg1, msg.arg2);
PhoneStateListener.this.onDataConnectionStateChanged(msg.arg1);
break;
case LISTEN_DATA_ACTIVITY:/*Listen for changes to the direction of data traffic on the data connection (cellular).对数据流量移动方向的变化监听*/
PhoneStateListener.this.onDataActivity(msg.arg1);
break;
case LISTEN_SIGNAL_STRENGTHS:/*Listen for changes to the network signal strengths (cellular).对网络信号强度的变化监听*/
PhoneStateListener.this.onSignalStrengthsChanged((SignalStrength)msg.obj);
break;
}
}
};
3.监听变化后发送消息
IPhoneStateListener callback = new IPhoneStateListener.Stub() {
public void onServiceStateChanged(ServiceState serviceState) {
Message.obtain(mHandler, LISTEN_SERVICE_STATE, 0, 0, serviceState).sendToTarget();
}
public void onSignalStrengthChanged(int asu) {
Message.obtain(mHandler, LISTEN_SIGNAL_STRENGTH, asu, 0, null).sendToTarget();
}
public void onMessageWaitingIndicatorChanged(boolean mwi) {
Message.obtain(mHandler, LISTEN_MESSAGE_WAITING_INDICATOR, mwi ? 1 : 0, 0, null)
.sendToTarget();
}
public void onCallForwardingIndicatorChanged(boolean cfi) {
Message.obtain(mHandler, LISTEN_CALL_FORWARDING_INDICATOR, cfi ? 1 : 0, 0, null)
.sendToTarget();
}
public void onCellLocationChanged(Bundle bundle) {
CellLocation location = CellLocation.newFromBundle(bundle);
Message.obtain(mHandler, LISTEN_CELL_LOCATION, 0, 0, location).sendToTarget();
}
public void onCallStateChanged(int state, String incomingNumber) {
Message.obtain(mHandler, LISTEN_CALL_STATE, state, 0, incomingNumber).sendToTarget();
}
public void onDataConnectionStateChanged(int state, int networkType) {
Message.obtain(mHandler, LISTEN_DATA_CONNECTION_STATE, state, networkType, null).
sendToTarget();
}
public void onDataActivity(int direction) {
Message.obtain(mHandler, LISTEN_DATA_ACTIVITY, direction, 0, null).sendToTarget();
}
public void onSignalStrengthsChanged(SignalStrength signalStrength) {
Message.obtain(mHandler, LISTEN_SIGNAL_STRENGTHS, 0, 0, signalStrength).sendToTarget();
}
};
posted @
2013-05-18 09:38 Terry Zou 阅读(346) |
评论 (0) |
编辑 收藏源文件为：
http://wenku.baidu.com/view/433b1585d4d8d15abe234e3a.html下面我简单写下这个例子：
第一，首先配置环境：
(1)添加jar包，如：sitemesh-2.4.1.jar放在lib下
在web.xml添加配置
<filter>
<filter-name>sitemesh</filter-name>
<filter-class>com.opensymphony.module.sitemesh.filter.PageFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>sitemesh</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>
第二步：
在WEB-INF下新建decorators.xml文件
内容如下：
<decorators defaultdir="/decorators">
<decorator name="main" page="main.jsp">
<pattern>/*</pattern>
</decorator>
</decorators>
第三步：
根据decorators.xml文件里面的属性defaultdir在webroot下创建一个目录decorators，在该目录下创建一个main.jsp文件
内容如下：
<%@ page contentType="text/html; charset=GBK"%>
<%@ include file="/includes/taglibs.jsp"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gbk">
<title><decorator:title default="装饰器页面..." /></title>
<decorator:head />
</head>
<body>
<div id="page">
<div id="header">
<jsp:include page="/includes/header.jsp"/>
</div>
<div id="content">
<decorator:body />
</div>
<div id="footer">
<jsp:include page="/includes/footer.jsp"/>
</div>
</body>
</html>
第四步
<jsp:include page="/includes/header.jsp"/>为includes目录下的一个共同使用的内容
<jsp:include page="/includes/footer.jsp"/>为includes目录下的一个共同使用的内容
<decorator:head /> 为每个要访问文件的内容
如下所示访问index.jsp
index.jsp内容为：
<%@ page contentType="text/html; charset=GBK"%>
<%@ include file="/includes/taglibs.jsp"%>
<html>
<head>
<title>Agent Test</title>
</head>
<body>
<p>本页只有就是本句.</p>
</body>
</html>
/includes/header.jsp内容为：
<%@ page language="java" contentType="text/html; charset=gbk"
pageEncoding="gbk"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gbk">
</head>
<body>
sitemesh的例<hr>
</body>
</html>
/includes/footer.jsp内容为：
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="gbk"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "
http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gbk">
<title>Insert title here</title>
</head>
<body>
<hr>chen56@msn.com
</body>
</html>
访问得到内容如下：
sitemesh的例
当然这里最主要的是要记住引入/include/taglibs.jsp
内容如下：
<%@ taglib uri="
http://www.opensymphony.com/sitemesh/decorator" prefix="decorator"%>
posted @
2013-05-15 16:04 Terry Zou 阅读(383) |
评论 (0) |
编辑 收藏
（1）如图文件位置所示
（2）文件内容如图所示：
（3）读取其中内容：Properties props = new Properties();
try {
int id = getApplicationContext().getResources().getIdentifier("androidpn", "raw", getPackageName());
props.load(getApplicationContext().getResources().openRawResource(id));
} catch (NotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
apiKey = props.getProperty("apiKey", "");
xmppHost = props.getProperty("xmppHost","");
xmppPort = props.getProperty("xmppPort","");
Log.v("", "apiKey:"+apiKey+" xmppHost:"+xmppHost+" xmppPort:"+xmppPort);
posted @
2013-05-11 14:44 Terry Zou 阅读(465) |
评论 (0) |
编辑 收藏
摘要: JSON的定义：原文地址：http://www.open-open.com/lib/view/open1326376799874.html
一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式 ，获得了当今大部分语言的支持），从而可以在不同平台...
阅读全文
posted @
2013-05-09 19:27 Terry Zou 阅读(350) |
评论 (1) |
编辑 收藏
BufferedReader br= req.getReader();
String version2 = br.readLine();
JSONObject js = JSONObject.fromObject(version2);
posted @
2013-05-08 20:32 Terry Zou 阅读(337) |
评论 (0) |
编辑 收藏1.建立连接
HttpClient httpclient = new DefaultHttpClient();
2.创建存放路径
Environment.getExternalStorageDirectory();
String saveDir =sdCardDir.getCanonicalPath() +"/DownFile";
File file1 = new File(saveDir);
if(!file1.exists()){
file1.mkdir();
}
3.选择传值方法（post或者get)
HttpPost httpRequest = new HttpPost(url);
HttpResponse response = httpclient.execute(httpRequest);
HttpEntity entity = response.getEntity();
BufferedHttpEntity bufHttpEntity = new BufferedHttpEntity(entity);
InputStream is = bufHttpEntity.getContent();
FileOutputStream out = new FileOutputStream(saveDir,false);
bufferedOutputStream = new BufferedOutputStream(
out);
bufferedInputStream = new BufferedInputStream(
is);
byte[] buf = new byte[4096];
int bytesRead = 0;
while (bytesRead >= 0) {
long now = System.currentTimeMillis();
bufferedOutputStream.write(buf, 0, bytesRead);
bytesRead = bufferedInputStream.read(buf);
}
bufferedOutputStream.flush();
4.关闭流及httpclient
bufferedOutputStream.close();
out.close();
if(bufferedOutputStream!=null){
bufferedOutputStream.close();
}
if(out!=null){
out.close();
}
if(bufferedInputStream!=null){
bufferedInputStream.close();
}
if(is!=null){
is.close();
}
shutdownHttpClient();
private void shutdownHttpClient() {
if (httpclient != null && httpclient.getConnectionManager() != null) {
httpclient.getConnectionManager().shutdown();
}
}
posted @
2013-05-08 20:30 Terry Zou 阅读(691) |
评论 (0) |
编辑 收藏举例说明什么情况下使用startActivityForResult？
就是当主界面（Activity）上能连接许多不同子功能模块(子Activity上去)，当子模块的事情做完之后就回到主界面，或许还同时返回一些子模块完成的数据交给主Activity处理。
举例如下：
功能A.java为主界面，B.java为功能模块，A启动B，B干完活，将数据又传送到A
先看 A.java 的相关代码
//-- A.java --//
/*
* 要做两件事情，第一是用 startActivityForResult() 启动B，其次是回收B的结果
*/
//启动B
Intent bintent = new Intent(A.this, B.class);
//设置 bintent的Bundle的一个值
String bsay = "Hello, this is B speaking";
bintent.putExtra("listenB", bsay)
startActivityForResult(bintent,0); // 参数(Intent intent, Int requestCode) 的 requestCode 对应下面回收Bundle时识别用的
//重写onActivityResult()来处理返回的数据，建议先看B.java 的代码再回来看这里比较好理解
//这理有三个参数 requestCode, resultCode, data
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
switch (resultCode) { //resultCode为回传的标记，我在B中回传的是RESULT_OK
case RESULT_OK:
Bundle b=data.getExtras(); //data为B中回传的Intent
String str=b.getString("ListenB");//str即为回传的值"Hello, this is B speaking"
/* 得到B回传的数据后做什么... 略 */
break;
default:
break;
}
}
-------------------------------------------------------------------------------------
//-- B.java --//
// 用 setResut() 准备好要回传的数据后，只要使用finish()的方法就能把打包好的数据发给A且运行onActivityResult()部分的代码
Intent aintent = new Intent(B.this, A.class);
/* 将数据打包到aintent Bundle 的过程略 */
setResut(RESULT_OK,aintent); //这理有2个参数(int resultCode, Intent intent)
... ...
finish();
-------------------------------------------------------------------------------------
OK，代码如上，可能这个时候还会有点疑问，关于参数的疑问。直接看android sdk 帮助说得更清楚。我发现网上有些文章还有吧 requestCode 和 resultCode 混淆说明错的。
startActivityForResult(Intent intent, Int requestCode)
intent 传给B的，不解释，看不懂你还是玩玩手机算了，别想开发的事情了
requestCode >=0就好，随便用于在onActivityResult()区别哪个子模块回传的数据，如果还有C.java ,D甚至E子模块的话，每个区分开不同的requestCode就好。
setResut(int resultCode, Intent intent)
resultCode 如果B子模块可能有几种不同的结果返回，可以用这个参数予以识别区分。这里还有个特殊的 RESULT_OK 值，没有特殊情况用它就好了，sdk有说明的，呵。
intent 继续不解释，传回给A的onActivityResult()
onActivityResult(int requestCode, int resultCode, Intent intent)
这里三个都不用解释了，与上文对应的东西。如果不对requestCode和resultCode 加以识别区分的话，只要有其他activity setResult到了A onActivityResult()会无差别处理。
引用如下：
http://www.cnblogs.com/mubai/archive/2011/09/21/2183816.htmlposted @
2013-05-08 20:19 Terry Zou 阅读(157) |
评论 (0) |
编辑 收藏首先，注意一点，连接服务器都不在主线程中进行，因为连接服务需要时间，这里简要介绍相关实现
public static HttpClient hc = null;
public static String server1 = "
http://192.168.6.74:8080/testHttpClient2/first";
private class DownloadPass extends Thread{
try {
hc = new DefaultHttpClient();
HttpPost httppost = new HttpPost(server1);
httppost.addHeader("Content-Type", "application/json");
httppost.addHeader("User-Agent", "imgfornote");
String model = android.os.Build.MODEL;
SharedPreferences preference0 = getSharedPreferences("serialNo", MODE_PRIVATE);
String serialNo = preference0.getString("serialNo", "0");
JSONObject obj = new JSONObject();
obj.put("serialNo", serialNo);
httppost.setEntity(new StringEntity(obj.toString()));
HttpResponse response;
response = hc.execute(httppost);
int code = response.getStatusLine().getStatusCode();
if(code==200){
str1 = EntityUtils.toString(response.getEntity());
}
if(str1!=null&&!str1.equals("")){
obj = new JSONObject(str1);
String url = obj.getString("url");
String updated = obj.getString("updated");
String serialNo1 = obj.getString("serialNo");
Intent intent = new Intent(Loading.this,DownloadPassService.class);
intent.putExtra("serialNo", serialNo1);
intent.putExtra("url", url.trim());
startService(intent);
}else{
SharedPreferences preference = getSharedPreferences("pass", MODE_PRIVATE);
preference.edit().clear().putBoolean("pass", true).commit();
}
} catch(ClientProtocolException e){
e.printStackTrace();
} catch (IOException e) {
mProgressHandler.sendEmptyMessage(20);
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally
{
//postMethod.releaseConnection();
shutdownHttpClient();
}
private void shutdownHttpClient() {
if (hc != null && hc.getConnectionManager() != null) {
hc.getConnectionManager().shutdown();
}
}
}
posted @
2013-05-08 19:28 Terry Zou 阅读(3374) |
评论 (0) |
编辑 收藏第一步：在我们的WEB项目中的
META-INF文件夹下建立一个
context.xml- <?xml version='1.0' encoding='utf-8'?>
-
- <Context>
-
- <Resource name="jdbc/mysql"
- auth="Container"
- type="javax.sql.DataSource"
- driverClassName="com.mysql.jdbc.Driver"
- url="jdbc:mysql://localhost/bbs"
- username="root"
- password="root"
- maxActive="50"
- maxIdle="20"
- maxWait="10000" />
-
- </Context>
<?xml version='1.0' encoding='utf-8'?>
<Context>
<Resource name="jdbc/mysql"
auth="Container"
type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost/bbs"
username="root"
password="root"
maxActive="50"
maxIdle="20"
maxWait="10000" />
</Context>
第二步：在我们的WEB项目下的
WEB-INF文件夹下建立一个
web.xml(如果存在了就不用了，直接修改就行了)
(这几天测试了一下，不做这步也可以，O(∩_∩)O哈哈~省事了)- <resource-ref>
- <description>DB Connection</description>
- <res-ref-name>jdbc/mysql</res-ref-name>
- <res-type>javax.sql.DataSource</res-type>
- <res-auth>Container</res-auth>
- </resource-ref>
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/mysql</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
第三步：我们就可以用代码来获取
Connection对象了
- package xushun.util;
-
- import java.sql.*;
- import javax.sql.*;
- import javax.naming.*;
-
- public class DBHelper {
-
- public static Connection getConnection() throws SQLException,NamingException
- {
-
- Context initContext = new InitialContext();
- Context envContext = (Context)initContext.lookup("java:/comp/env");
-
- DataSource ds = (DataSource)envContext.lookup("jdbc/mysql");
- return ds.getConnection();
- }
- }
package xushun.util;
import java.sql.*;
import javax.sql.*;
import javax.naming.*;
public class DBHelper {
public static Connection getConnection() throws SQLException,NamingException
{
// 初始化查找命名空间
Context initContext = new InitialContext();
Context envContext = (Context)initContext.lookup("java:/comp/env");
// 找到DataSource
DataSource ds = (DataSource)envContext.lookup("jdbc/mysql");
return ds.getConnection();
}
}
2.把DataSource设置到我们的Tomcat中，下面详细的介绍下（测试用的JAVA代码和上面的一样就不帖出了）：这里我查到的设置方法就有了一点区别了。有的人把DataSource设置在Tomcat的server.xml文件的GlobalNamingResources下面，然后在context.xml中去映射。有的直接就写在context.xml中了
先说下在server.xml添加DataSource第一步：在Tomcat的conf中的server.xml文件中找到
- <GlobalNamingResources>
- <!-- Editable user database that can also be used by
- UserDatabaseRealm to authenticate users
- -->
- <Resource name="UserDatabase" auth="Container"
- type="org.apache.catalina.UserDatabase"
- description="User database that can be updated and saved"
- factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
- pathname="conf/tomcat-users.xml" />
- </GlobalNamingResources>
<GlobalNamingResources>
<!-- Editable user database that can also be used by
UserDatabaseRealm to authenticate users
-->
<Resource name="UserDatabase" auth="Container"
type="org.apache.catalina.UserDatabase"
description="User database that can be updated and saved"
factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
pathname="conf/tomcat-users.xml" />
</GlobalNamingResources>修改为
- <GlobalNamingResources>
- <!-- Editable user database that can also be used by
- UserDatabaseRealm to authenticate users
- -->
- <Resource name="UserDatabase" auth="Container"
- type="org.apache.catalina.UserDatabase"
- description="User database that can be updated and saved"
- factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
- pathname="conf/tomcat-users.xml" />
- <Resource name="jdbc/bbs"
- auth="Container" type="javax.sql.DataSource"
- driverClassName="com.mysql.jdbc.Driver"
- maxIdle="20"
- maxWait="5000"
- username="root"
- password="admin"
- url="jdbc:mysql://localhost:3306/bbs"
- maxActive="100"
- removeAbandoned="true"
- removeAbandonedTimeout="60"
- logAbandoned="true"/>
- </GlobalNamingResources>
<GlobalNamingResources>
<!-- Editable user database that can also be used by
UserDatabaseRealm to authenticate users
-->
<Resource name="UserDatabase" auth="Container"
type="org.apache.catalina.UserDatabase"
description="User database that can be updated and saved"
factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
pathname="conf/tomcat-users.xml" />
<Resource name="jdbc/bbs"
auth="Container" type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
maxIdle="20"
maxWait="5000"
username="root"
password="admin"
url="jdbc:mysql://localhost:3306/bbs"
maxActive="100"
removeAbandoned="true"
removeAbandonedTimeout="60"
logAbandoned="true"/>
</GlobalNamingResources>第二步：在Tomcat的conf文件夹下的context.xml中加入
- <ResourceLink name="jdbc/bbs" global="jdbc/bbs" type="javax.sql.DataSource"/>
<ResourceLink name="jdbc/bbs" global="jdbc/bbs" type="javax.sql.DataSource"/>
第三步：就是在WEB项目的WEB-INF中的web.xml添加
- <resource-ref>
- <description>DB Connection</description>
- <res-ref-name>jdbc/mysql</res-ref-name>
- <res-type>javax.sql.DataSource</res-type>
- <res-auth>Container</res-auth>
- </resource-ref>
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/mysql</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
还有就是在Tomcat文档中提到的方法，直接修改context.xml文件了在Tomcat的conf文件夹下的context.xml中加入
- <Resource name="jdbc/bbs"
- auth="Container" type="javax.sql.DataSource"
- driverClassName="com.mysql.jdbc.Driver"
- maxIdle="20"
- maxWait="5000"
- username="root"
- password="admin"
- url="jdbc:mysql://localhost:3306/bbs"
- maxActive="100"
- removeAbandoned="true"
- removeAbandonedTimeout="60"
- logAbandoned="true"/>
<Resource name="jdbc/bbs"
auth="Container" type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
maxIdle="20"
maxWait="5000"
username="root"
password="admin"
url="jdbc:mysql://localhost:3306/bbs"
maxActive="100"
removeAbandoned="true"
removeAbandonedTimeout="60"
logAbandoned="true"/>
然后就是在WEB项目的WEB-INF中的web.xml添加
- <resource-ref>
- <description>DB Connection</description>
- <res-ref-name>jdbc/mysql</res-ref-name>
- <res-type>javax.sql.DataSource</res-type>
- <res-auth>Container</res-auth>
- </resource-ref>
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/mysql</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
就是这些了，如果有什么不太清楚的就留言，一起研究下。等以后我在搜集下资料整理出上面用到的XML文件中各个标签的属性及其代表的意思。有兴趣的也可以自己先查下。:-)<td>JNDI 查找名称</td> <td>关联的引用</td>
<td>java:comp/env</td> <td>应用程序环境条目</td>
<td>java:comp/env/jdbc</td> <td>JDBC 数据源资源管理器连接工厂</td>
<td>java:comp/env/ejb</td> <td>EJB 引用</td>
<td>java:comp/UserTransaction</td><td>UserTransaction 引用</td>
<td>java:comp/env/mail</td> <td>JavaMail 会话连接工厂</td>
<td>java:comp/env/url</td> <td>URL 连接工厂</td>
<td>java:comp/env/jms</td> <td>JMS 连接工厂和目标</td>
<td>java:comp/ORB</td> <td>应用程序组件之间共享的 ORB 实例</td>
参考如下
posted @
2012-07-27 19:29 Terry Zou 阅读(3049) |
评论 (0) |
编辑 收藏Window->>Preferences>>JVM Settings在Append to the Parameters文本框中加入要设置的内存大小，比如下面的设置
-Xms128M -Xmx512M -XX:PermSize=64M -XX:MaxPermSize=128M
posted @
2012-03-20 09:55 Terry Zou 阅读(191) |
评论 (0) |
编辑 收藏posted @
2012-03-15 19:46 Terry Zou 阅读(506) |
评论 (0) |
编辑 收藏
当文本中定义了相同的id值或相同的class值时，定义为id不可以同时操作，定义为class可以同时对那些值进行操作。如下例所示：
描述要求，要求点击按钮时能够对两个文本框进行隐藏
下面情况不能达到效果(当然jquery包已经导入啦)：
<html>
<head>
<script type="text/javascript">
$(document).ready(function(){
$("#button").click(function(){
$("#tx1").hide();
});
});
</script>
</head>
<body>
<input type="text" id="tx1" />
<input type="text" id="tx1" />
<input type="button" id="button" />
</body>
</html>
下面情况能行
<html>
<head>
<script type="text/javascript">
$(document).ready(function(){
$(".button").click(function(){
$(".tx1").hide();
});
});
</script>
</head>
<body>
<input type="text" class="tx1" />
<input type="text" class="tx1" />
<input type="button" class="button" />
</body>
</html>
posted @
2011-07-28 19:18 Terry Zou 阅读(162) |
评论 (0) |
编辑 收藏 在jquery中可以通过jqueryObj.attr("disabled","disabled")将页面中某个元素置为不可编辑或触发状态，但是在jquery的API reference中并没说明怎么将页面置为disable的元素重新置为可触发或可编辑的。这里发现可以采用三种的变通方法将置为disabled的元素状态改为enabled
1.将disabled属性设为false
如：对文本进行设置
<input type="text" name="user" id="userId" />
$("#userId").attr("disabled",false);
2.将disabled属性设为空
如:同样是上面文本
$("#userId").attr("disabled","");
3.移除disabled属性
如:同样用到上面文本
$("#userId").removeAttr("disabled");
详细出处参考：http://www.jb51.net/article/19342.htm
posted @
2011-07-27 20:28 Terry Zou 阅读(249) |
评论 (0) |
编辑 收藏1.toggle有两种形式
（1）toggle()用于切换元素的可见性，如果被选元素可见，则隐藏这些元素，如果被选元素不可见，则显示这些元素。
如:
<body>
<p id="content">当点击上面的“点击这里字样”，这里的内容将隐藏与显示切换</p>
<input type="button" id="test" value="点击这里"></input>
</body>
$(document).ready(function(){
$("#test").click(function(){
$("#content").toggle();
});
});
(2)toggle(f(n),f(m)) 效果是：每次点击后依次调用函数；如果点击了一个匹配的元素，则触发指定的第一个函数，当再次点击同一元素时，则触发指定的第二个函数，如果有更多函数，则再次触发，直到最后一个。随后的每次点击都重复对这几个函数的轮番调用.
<body>
<p id="content">当点击上面的“点击这里字样”，这里的内容颜色将切换</p>
<input type="button" id="test" value="点击这里"></input>
</body>
样式：
.bg{color:#ff0;}
.cg{color:#f0f;}
$(document).ready(function(){
$("#test").toggle(
function(){
$("#content").addClass("bg");
},
function(){
$("#content").removeClass("bg");
},
function(){
$("#content").addClass("cg");
});
});
当然这里不能循环执行，应为当执行完addClass("cg")时就得执行addClass("bg")这是错误的，应该在将cg样式去掉就ok啦，可以在下面在加一个去掉的函数。
2.hover一个模仿悬停事件（鼠标移动到一个对象上面及移出这个对象）的方法,效果：当鼠标移动到一个匹配的元素上面时，会触发指定的第一个函数。当鼠标移出这个元素时，会触发指定的第二个函数。而且，会伴随着对鼠标是否仍然处在特定元素中的检测（例如，处在div中的图像），如果是，则会继续保持“悬停”状态，而不触发移出事件（修正了使用mouseout事件的一个常见错误）。
$("#content").hover(function(){
$(this).addClass("bg");},
function(){
$(this).removeClass("bg");
});
这里只写这两个例子，其他的参加下面的事件汇总。来源：
http://www.cnblogs.com/EricChan/archive/2011/02/01/1948534.html
方法 描述
ready() 文档就绪事件（当 HTML 文档就绪可用时）
blur() 触发、或将函数绑定到指定元素的 blur 事件
change() 触发、或将函数绑定到指定元素的 change 事件
click() 触发、或将函数绑定到指定元素的 click 事件
dblclick() 触发、或将函数绑定到指定元素的 double click 事件
error() 触发、或将函数绑定到指定元素的 error 事件
focus() 触发、或将函数绑定到指定元素的 focus 事件
keydown() 触发、或将函数绑定到指定元素的 key down 事件
keypress() 触发、或将函数绑定到指定元素的 key press 事件
keyup() 触发、或将函数绑定到指定元素的 key up 事件
load() 触发、或将函数绑定到指定元素的 load 事件
mousedown() 触发、或将函数绑定到指定元素的 mouse down 事件
mouseenter() 触发、或将函数绑定到指定元素的 mouse enter 事件
mouseleave() 触发、或将函数绑定到指定元素的 mouse leave 事件
mousemove() 触发、或将函数绑定到指定元素的 mouse move 事件
mouseout() 触发、或将函数绑定到指定元素的 mouse out 事件
mouseover() 触发、或将函数绑定到指定元素的 mouse over 事件
mouseup() 触发、或将函数绑定到指定元素的 mouse up 事件
resize() 触发、或将函数绑定到指定元素的 resize 事件
scroll() 触发、或将函数绑定到指定元素的 scroll 事件
select() 触发、或将函数绑定到指定元素的 select 事件
submit() 触发、或将函数绑定到指定元素的 submit 事件
unload() 触发、或将函数绑定到指定元素的 unload 事件
jQuery 事件处理方法
事件处理方法把事件处理器绑定至匹配元素。
方法 触发
$(selector).bind(event) 向匹配元素添加一个或更多事件处理器
$(selector).delegate(selector, event) 向匹配元素添加一个事件处理器，现在或将来
$(selector).die() 移除所有通过 live() 函数添加的事件处理器
$(selector).live(event) 向匹配元素添加一个事件处理器，现在或将来
$(selector).one(event) 向匹配元素添加一个事件处理器。该处理器只能触发一次。
$(selector).unbind(event) 从匹配元素移除一个被添加的事件处理器
$(selector).undelegate(event) 从匹配元素移除一个被添加的事件处理器，现在或将来
$(selector).trigger(event) 所有匹配元素的指定事件
$(selector).triggerHandler(event) 第一个被匹配元素的指定事件
jQuery 效果函数
Hide / Show 描述
show() 显示被选的元素
hide() 隐藏被选的元素
toggle() 对被选元素进行隐藏和显示的切换
Slide
slideDown() 通过调整高度来滑动显示被选元素
slideUp() 通过调整高度来滑动隐藏被选元素
slideToggle() 对被选元素进行滑动隐藏和滑动显示的切换
Fade in / out
fadeIn() 淡入被选元素至完全不透明
fadeOut() 淡出被选元素至完全不透明
fadeTo() 把被选元素减弱至给定的不透明度
Animation
animate() 对被选元素应用“自定义”的动画
stop() 停止在被选元素上运行动画
Queue
clearQueue() 对被选元素移除所有排队的函数（仍未运行的）
delay() 对被选元素的所有排队函数（仍未运行）设置延迟
dequeue() 运行被选元素的下一个排队函数
queue() 显示被选元素的排队函数
jQuery 文档操作方法
这些方法对于 XML 文档和 HTML 文档均是适用的，除了：html()。
方法 描述
addClass() 向匹配的元素添加指定的类名。
after() 在匹配的元素之后插入内容。
append() 向匹配的元素内部追加内容。
appendTo() 向匹配的元素内部追加内容。
attr() 设置或返回匹配元素的属性和值。
before() 在每个匹配的元素之前插入内容。
clone() 创建匹配元素集合的副本。
detach() 从 DOM 中移除匹配元素集合。
empty() 删除匹配的元素集合中所有的子节点。
hasClass() 检查匹配的元素是否拥有指定的类。
html() 设置或返回匹配的元素集合中的 HTML 内容。
insertAfter() 把匹配的元素插入到另一个指定的元素集合的后面。
insertBefore() 把匹配的元素插入到另一个指定的元素集合的前面。
prepend() 向每个匹配的元素内部前置内容。
prependTo() 向每个匹配的元素内部前置内容。
remove() 移除所有匹配的元素。
removeAttr() 从所有匹配的元素中移除指定的属性。
removeClass() 从所有匹配的元素中删除全部或者指定的类。
replaceAll() 用匹配的元素替换所有匹配到的元素。
replaceWith() 用新内容替换匹配的元素。
text() 设置或返回匹配元素的内容。
toggleClass() 从匹配的元素中添加或删除一个类。
unwrap() 移除并替换指定元素的父元素。
val() 设置或返回匹配元素的值。
wrap() 把匹配的元素用指定的内容或元素包裹起来。
wrapAll() 把所有匹配的元素用指定的内容或元素包裹起来。
wrapinner() 将每一个匹配的元素的子内容用指定的内容或元素包裹起来。
jQuery 属性操作方法
下面列出的这些方法获得或设置元素的 DOM 属性。
这些方法对于 XML 文档和 HTML 文档均是适用的，除了：html()。
方法 描述
addClass() 向匹配的元素添加指定的类名。
attr() 设置或返回匹配元素的属性和值。
hasClass() 检查匹配的元素是否拥有指定的类。
html() 设置或返回匹配的元素集合中的 HTML 内容。
removeAttr() 从所有匹配的元素中移除指定的属性。
removeClass() 从所有匹配的元素中删除全部或者指定的类。
toggleClass() 从匹配的元素中添加或删除一个类。
val() 设置或返回匹配元素的值。
注释：jQuery 文档操作参考手册中也列出了以上方法。本参考页的作用是方便用户单独查阅有关属性操作方面的方法。
jQuery CSS 操作函数
下面列出的这些方法设置或返回元素的 CSS 相关属性。
CSS 属性 描述
css() 设置或返回匹配元素的样式属性。
height() 设置或返回匹配元素的高度。
offset() 返回第一个匹配元素相对于文档的位置。
offsetParent() 返回最近的定位祖先元素。
position() 返回第一个匹配元素相对于父元素的位置。
scrollTop() 设置或返回匹配元素相对滚动条顶部的偏移。
scrollLeft() 设置或返回匹配元素相对滚动条左侧的偏移。
width() 设置或返回匹配元素的宽度。
jQuery Ajax 操作函数
jQuery 库拥有完整的 Ajax 兼容套件。其中的函数和方法允许我们在不刷新浏览器的情况下从服务器加载数据。
函数 描述
jQuery.ajax() 执行异步 HTTP (Ajax) 请求。
.ajaxComplete() 当 Ajax 请求完成时注册要调用的处理程序。这是一个 Ajax 事件。
.ajaxError() 当 Ajax 请求完成且出现错误时注册要调用的处理程序。这是一个 Ajax 事件。
.ajaxSend() 在 Ajax 请求发送之前显示一条消息。
jQuery.ajaxSetup() 设置将来的 Ajax 请求的默认值。
.ajaxStart() 当首个 Ajax 请求完成开始时注册要调用的处理程序。这是一个 Ajax 事件。
.ajaxStop() 当所有 Ajax 请求完成时注册要调用的处理程序。这是一个 Ajax 事件。
.ajaxSuccess() 当 Ajax 请求成功完成时显示一条消息。
jQuery.get() 使用 HTTP GET 请求从服务器加载数据。
jQuery.getJSON() 使用 HTTP GET 请求从服务器加载 JSON 编码数据。
jQuery.getScript() 使用 HTTP GET 请求从服务器加载 JavaScript 文件，然后执行该文件。
.load() 从服务器加载数据，然后把返回到 HTML 放入匹配元素。
jQuery.param() 创建数组或对象的序列化表示，适合在 URL 查询字符串或 Ajax 请求中使用。
jQuery.post() 使用 HTTP POST 请求从服务器加载数据。
.serialize() 将表单内容序列化为字符串。
.serializeArray() 序列化表单元素，返回 JSON 数据结构数据。
jQuery 遍历函数
jQuery 遍历函数包括了用于筛选、查找和串联元素的方法。
| 函数 |
描述 |
| .add() |
将元素添加到匹配元素的集合中。 |
| .andSelf() |
把堆栈中之前的元素集添加到当前集合中。 |
| .children() |
获得匹配元素集合中每个元素的所有子元素。 |
| .closest() |
从元素本身开始，逐级向上级元素匹配，并返回最先匹配的祖先元素。 |
| .contents() |
获得匹配元素集合中每个元素的子元素，包括文本和注释节点。 |
| .each() |
对 jQuery 对象进行迭代，为每个匹配元素执行函数。 |
| .end() |
结束当前链中最近的一次筛选操作，并将匹配元素集合返回到前一次的状态。 |
| .eq() |
将匹配元素集合缩减为位于指定索引的新元素。 |
| .filter() |
将匹配元素集合缩减为匹配选择器或匹配函数返回值的新元素。 |
| .find() |
获得当前匹配元素集合中每个元素的后代，由选择器进行筛选。 |
| .first() |
将匹配元素集合缩减为集合中的第一个元素。 |
| .has() |
将匹配元素集合缩减为包含特定元素的后代的集合。 |
| .is() |
根据选择器检查当前的匹配元素集合，如果存在至少一个匹配元素，则返回 true。 |
| .last() |
将匹配元素集合缩减为集合中的最后一个元素。 |
| .map() |
把当前匹配集合中的每个元素传递给一个函数，产生包含返回值的新的 jQuery 对象。 |
| .next() |
获得匹配元素集合中每个元素紧邻的同辈元素。 |
| .nextAll() |
获得匹配元素集合中每个元素之后的所有同辈元素，由选择器进行筛选（可选）。 |
| .nextUntil() |
获得每个元素之后所有的同辈元素，直到遇到匹配选择器的元素为止。 |
| .not() |
从匹配元素集合中删除元素。 |
| .offsetParent() |
获得用于定位的第一个父元素。 |
| .parent() |
获得当前匹配元素集合中每个元素的父元素，由选择器筛选（可选）。 |
| .parentsUntil() |
获得当前匹配元素集合中每个元素的祖先元素，直到遇到匹配选择器的元素为止。 |
| .prev() |
获得匹配元素集合中每个元素紧邻的前一个同辈元素，由选择器筛选（可选）。 |
| .prevAll() |
获得匹配元素集合中每个元素之前的所有同辈元素，由选择器进行筛选（可选）。 |
| .prevUntil() |
获得每个元素之前所有的同辈元素，直到遇到匹配选择器的元素为止。 |
| .siblings() |
获得匹配元素集合中所有元素的同辈元素，由选择器筛选（可选）。 |
| .slice() |
将匹配元素集合缩减为指定范围的子集。 |
jQuery 数据存储函数
这些方法允许我们将指定的 DOM 元素与任意数据相关联。
| 函数 |
描述 |
| .data() |
存储与匹配元素相关的任意数据。 |
| jQuery.data() |
存储与指定元素相关的任意数据。 |
| .removeData() |
移除之前存放的数据。 |
| jQuery.removeData() |
移除之前存放的数据。 |
jQuery 队列控制函数
| 函数 |
描述 |
| .clearQueue() |
从队列中删除所有未运行的项目。 |
| .dequeue() |
从队列最前端移除一个队列函数，并执行它。 |
| jQuery.dequeue() |
从队列最前端移除一个队列函数，并执行它。 |
| .queue() |
显示或操作匹配元素所执行函数的队列。 |
| jQuery.queue() |
显示或操作匹配元素所执行函数的队列。 |
posted @
2011-07-22 20:53 Terry Zou 阅读(211) |
评论 (0) |
编辑 收藏val()方法取值，<select>元素默认的为value属性值，否则为<option value="">value</option>;<input type='checkbox' value="">默认为value属性值，否则为on;<input type="text" value=""></input>默认为输入到文本框里的值;<input type="radio" id="abc" value="">abc</input>默认为value属性值，否则为on;
1.处理Select事件
<select id="select">
<option>苹果</option>
<option>栗子</option>
<option>桃子</option>
</select>
当$('#select').val();默认的值为选择的值，如“苹果”,但<option value="冬瓜">苹果</option>在选择苹果是$('#select').val();得到的是“冬瓜”。
（1）为select添加选项值，如下:
<html>
<head>
<title>添加选项</title>
<script type="text/javascript">
$(document).ready(function(){
$(".info").append($("<option></option>").attr("value","1").text("苹果"));
});
</script>
</head>
<body>
<form>
<select class="info"></select>
</form>
</body>
</html>
（2）获取select中的被选项，如下:
<html>
<head>
<title>获取被选项</title>
<script type="text/javascript">
$(document).ready(function(){
$("#bt").click(function(){
var fruit=$("select option:selected").val();
alert(fruit);
});
</script>
</head>
<body>
<form>
<select class="info">
<option>苹果</option>
<option>栗子</option>
<option>桃子</option>
</select>
<input type="button" id="bt">按钮</input>
</form>
</body>
</html>
2.处理checkbox事件
（1）全选uncheck/checkAll
<div class="infobox"><input type="checkbox" name="a" id="a" value=1>看电影</input></div>
<div class="infobox"><input type="checkbox" name="b" id="b" value=2>打篮球</input></div>
<div class="infobox"><input type="checkbox" name="c" id="c" value=3>看书</input></div>
<div class="infobox"><input type="checkbox" id="checkAll">Check/Uncheck</input></div>
$(document).ready(function(){
$('#checkAll').click(function(){
$("input[type='checkbox']").attr('checked',$("#checkAll").is(':checked'));
});
});
(2) 检查复选框是否被选中
$('form').find(":checkbox").each(function(){
if($(this).is(":checked");
});
3.处理radio事件
（1）检查单选按钮是否被选择
var a=$("input[type='radio']:checked").val();
posted @
2011-07-21 21:02 Terry Zou 阅读(560) |
评论 (0) |
编辑 收藏1.利用数组在列表中显示名字
(1)纵向显示
如:<script type="text/javascript>
$(document).ready(function(){
var member = ["John","Kate","Peter"];
$('p').html(member.join('<br />'));
}
</script>
（2）显示名字及其在数组中所在位置
如:<script type="text/javascript>
$(document).ready(function(){
var member = ["John","Kate","Peter"];
$.each(member,function(n,value){
$('ol').append($('<li>'+value+'</li>'));
});
});
</script>
(3)
利用Html
元素创建数组及计数数组的长度
$(document).ready(function(){
Var names=$(‘li’).get(); //创建数组
$(‘p’).text(names.length); //计数数组长度
});
2.操作数组数据(转换成大写)
$(document).ready(function(){
var member=["zhangsan","BoLaiTe"];
var member=$.map(member,function(n,i){ //member可以变为其他数组名
return (i+1+"."+n.toUpperCase());
});
});
注:$.each()和$.map()都是迭代数组中的每个元素，并调用回调函数对每个元素做操作。后者还能返回一个数组元素。
3.筛选数组元素
(1)使用grep
$(document).ready(function(){
member=["Dev","Tom"];
member=$.grep(member,function(v){return v.length>3});
});
(2)使用match
member=["Dev","Tom"];
member=$.grep(member,function(v){return v.match(/^[A-D]/)});
4.字符串数组，数值数组排序
（1）字符串数组排序
var member=["dev","Tom"]
member=member.sort();
(2) 数值数组排序
var memer=[12,34,13,53];
member=member.sort(function(a,b){
return a-b;
});
(3)对象数组排序
<script type="text/javascript" src="rs/js/jquery.js"></script>
<script type="text/javascript">
<!--
$(
function()
{
var students =[
{'sid':'ST001','sname':'张三','sage':18},
{'sid':'ST004','sname':'赵六','sage':23},
{'sid':'ST002','sname':'李四','sage':42},
{'sid':'ST003','sname':'王五','sage':35}
];
//表格显示
$.each(students,
function(index, value)
{
$('#ia').append('<tr><td>' + value.sid +
'</td><td>' + value.sname +
'</td><td>' + value.sage + '</td></tr>');
}
);
//按照SID排序
var sidOrder = students.sort(
function(a, b)
{
if(a.sid < b.sid) return -1;
if(a.sid > b.sid) return 1;
return 0;
}
);
$.each(sidOrder,
function(index, value)
{
$('#ib').append('<tr><td>' + value.sid +
'</td><td>' + value.sname +
'</td><td>' + value.sage + '</td></tr>')
}
);
//按照SAGE排序
var sageOrder = students.sort(
function(a, b)
{
return (a.sage - b.sage);
}
);
$.each(sageOrder,
function(index, value)
{
$('#ic').append('<tr><td>' + value.sid +
'</td><td>' + value.sname +
'</td><td>' + value.sage + '</td></tr>')
}
);
}
);
//-->
</script>
注：上述来源于：http://mmz06.blog.163.com/blog/static/12141696201102935021258/
5.拆分数组
var member=[20,40,21,302,21];
var memSecond=member.splice(1,2);
得到 member=[20,302,21];
memSecond=[40,21];
6.合并数组
var mem1=[1,2];
var mem2=[3,4];
var mem=mem1.concat(mem2);
posted @
2011-07-21 20:47 Terry Zou 阅读(1269) |
评论 (0) |
编辑 收藏一.jQuery基础
1. jQuery选择dom节点
$(‘p’) //html元素<p>
$(‘div’) //html元素<div>
$(‘#A’) //id='A'
$(‘.b’) //class='b'
2. 延迟JavaScript的执行
用来通知我们dom准备就绪的方法是$(document).ready()。在DOM加载完成后,此方法执行函数调用：
$(document).ready(function(){
$(‘p’).addClass(‘hightlight’);
});
3. css放在元素上
$(‘div’).addClass(‘hightlight’);
4. 选择系列非标准的HTML元素
$(‘div:odd’).addClass(‘highlight’);
$(‘div:even’).addClass(‘boundary’);
$(‘p:eq(1)’).addClass(‘linkstyle’);
5. 计数dom节点和显示其文本
$(document).ready(function(){
var $node=$(“#root”).children();
alert($node.length);
var text;
$(“#root”).children.each(function(){
text+=$(this).text();
})
})
6. 获取html代码
$(‘p’).html();
7. 获取dom代码
$(‘h2’).text(‘javascript libraries’);
8. 快速创建dom节点
(1) prepend()指定元素前插入
$(‘p’).prend(‘<h2>abc</h2>’);
(2) prependTo()
$(‘<h2>abc</h2>’).prependTo(‘p’);
(3) clone()复制指定元素并返回一个新的jQuery对象。复制一个h2元素插入该段元素 $(‘h2’).clone().prependTo(‘p’);
posted @
2011-07-21 19:33 Terry Zou 阅读(186) |
评论 (0) |
编辑 收藏