Java的動態代理是為了攔截目標方法，例子：
public interface Person {
String sing(String name);
String dance(String name);
}
public class Liyuchun implements Person {
public String sing(String name){
System.out.println("唱" + name +"歌");
return "唱" + name +"歌";
}
public String dance(String name){
System.out.println("跳"+name+"舞");
return "跳"+name+"舞";
}
}
public class LiyuchunProxy {
private Person person ;
public Person createProxy(Person p){
this.person=p;
return (Person) Proxy.newProxyInstance(LiyuchunProxy.class.getClassLoader(), person.getClass().getInterfaces(), new InvocationHandler(){
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
String methodName = method.getName();
if(methodName.equals("sing")){
return method.invoke(person, args);
}else if(methodName.equals("dance")){
return method.invoke(person, args);
}else{
System.out.println("不支持");
return null;
}
}
});
}
}
public class ProxyTest {
public static void main(String[] args) {
Liyuchun cun = new Liyuchun();
LiyuchunProxy liyuchunProxy = new LiyuchunProxy();
Person person = liyuchunProxy.createProxy(cun);
String result = person.dance("機械");
System.out.println(result);
}
}
public class Bean1 {
private String a;
private String b;
private String time;
public String getA() {
return a;
}
public void setA(String a) {
this.a = a;
}
public String getB() {
return b;
}
public void setB(String b) {
this.b = b;
}
public String getTime() {
return time;
}
public void setTime(String time) {
this.time = time;
}
}
public class Bean2 {
private int a;
private String b;
private Date time;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public String getB() {
return b;
}
public void setB(String b) {
this.b = b;
}
public Date getTime() {
return time;
}
public void setTime(Date time) {
this.time = time;
}
}
import java.lang.reflect.InvocationTargetException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
public class Test {
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException {
Bean1 bean1 = new Bean1();
bean1.setA("22");
bean1.setB("fff");
bean1.setTime("2017-01-22 11:11:11");
Bean2 bean2 = new Bean2();
resp();
BeanUtils.copyProperties(bean2, bean1);
System.out.println(bean2.getA());
System.out.println(bean2.getB());
System.out.println(bean2.getTime());
}
private static void resp() {
ConvertUtils.register(new Converter() {
@Override
public Object convert(Class arg0, Object value) {
if(value != null &&!"".equals(value.toString())){
String v=value.toString();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:MM:ss");
try {
return sdf.parse(v);
} catch (ParseException e) {
e.printStackTrace();
}
}
return null;
}
}, Date.class);
}
}
當一個不在spring容器中的一個類，需要用到事務，這時需要調用spring容器中的其他類來實現事務。比如：
在類中使用context.getBean("aService");得到服務類，此服務類含有事務。
1、配置spring文件：
<beans xmlns="http://www.springframework.org/schema/beans"
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-2.5.xsd">
<!--
讀取配置文件
-->
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<value>classpath:jdbc.properties</value>
</property>
</bean>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<bean id="classesDao" class="cn.itheima03.spring.jdbc.ClassesDaoImpl">
<property name="dataSource">
<ref bean="dataSource"/>
</property>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<constructor-arg index="0" ref="dataSource"></constructor-arg>
</bean>
<bean id="classesDao2" class="cn.itheima03.spring.jdbc.ClassesDaoImpl2">
<property name="jdbcTemplate">
<ref bean="jdbcTemplate"/>
</property>
</bean>
<bean id="itheimaTemplate" class="cn.itheima03.spring.itheima03db.ItHeimaTemplate">
<constructor-arg index="0" ref="dataSource"></constructor-arg>
</bean>
<bean id="classesDao4" class="cn.itheima03.spring.itheima03db.ClassesDaoImpl4">
<constructor-arg index="0" ref="dataSource"></constructor-arg>
</bean>
<bean id="classesDao3" class="cn.itheima03.spring.jdbc.ClassesDaoImpl3">
<constructor-arg index="0" ref="dataSource"></constructor-arg>
</bean>
</beans>
2、第一種方式：
public class ClassesDaoImpl extends JdbcDaoSupport implements ClassesDao{
public void saveClasses() {
this.getJdbcTemplate().execute("insert into classes(cname,description) values('a','a')");
}
@Override
public List<Classes> getClasses() {
// TODO Auto-generated method stub
return this.getJdbcTemplate().query("select * from classes", new ClassesRowMapper());
}
}
3、第二種方式：
public class ClassesDaoImpl2 implements ClassesDao{
private JdbcTemplate jdbcTemplate;
public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
}
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public void saveClasses() {
// TODO Auto-generated method stub
this.jdbcTemplate.execute("insert into classes(cname,description) values('a','a')");
}
@Override
public List<Classes> getClasses() {
// TODO Auto-generated method stub
return null;
}
}
4.第三種方式：
public class ClassesDaoImpl3 extends JdbcTemplate implements ClassesDao{
public ClassesDaoImpl3(DataSource dataSource){
super(dataSource);
}
public void saveClasses() {
this.execute("insert into classes(cname,description) values('a','a')");
}
@Override
public List<Classes> getClasses() {
return null;
}
}
5、自定義數據庫操作類：
public class ItHeimaTemplate {
private DataSource dataSource;
public DataSource getDataSource() {
return dataSource;
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public ItHeimaTemplate(){}
public ItHeimaTemplate(DataSource dataSource){
this.dataSource = dataSource;
}
public void insert(String sql){
try {
Connection conn = this.dataSource.getConnection();
Statement statement = conn.createStatement();
statement.executeUpdate(sql);
} catch (Exception e) {
}
}
}
public class ClassesDaoImpl4 extends ItHeimaTemplate{
public ClassesDaoImpl4(DataSource dataSource){
super(dataSource);
}
public void insert(){
this.insert("insert into classes(cname,description) values('a','a')");
}
}
$().ready(function(){
for (var i = 0; i < 300; i++) {
$("input[type='button']").unbind("click");
$("input[type='button']").bind("click",function(){
/**
* 觸發自定義的事件
*/
$(this).trigger("楊軍威",{
a:5,
b:6
});
});
}
$("input[type='button']").unbind("楊軍威");
$("input[type='button']").bind("楊軍威",function(event,json){
alert(json.a+json.b);
});
});
/**
* 自定義事件
* 1、自定義一個事件，該事件的名稱為"云三很牛"
* 2、把該事件綁定在button上
* 3、該事件在點擊button的時候觸發
*/
1、session有緩存功能，但是當session關閉后，緩存消失。
2.二級緩存是sessionfactory級別的，當hibernate容器啟動后，
二級緩存就存在了，當hibernate關閉后，二級緩存消失。
hibernate本身對于二級緩存是關閉的，而且沒有實現二級緩存的機制。
在hibernate.cfg.xml文件中配置：
<!-- 啟用二級緩存 --><property name="hibernate.cache.use_second_level_cache">true</property><property name="hibernate.cache.use_query_cache">true</property><!-- 配置緩存提供商 --><property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
在實體類中配置
<class-cache class="com.nacosoft.pda.user.PdaUser" usage="read-write" />
如果想開啟集合的二級緩存，需要開啟針對集合類的二級緩存。
如果二級緩存的數據量大，可以在src目錄下新建ehcache.xml文件，把數據緩存在磁盤上。
3.查詢緩存：在二級緩存的基礎上，在代碼里寫：
Query query = session.createQuery("from Person");
query.setCacheable(true);
List list = query.list();
就可以使用查詢緩存了
1、sessionFactory.openSession()，只要調用此方法，就會產生一個新的session。
2、sessionFactory.getCurrentSession()產生session的邏輯是：
先判斷當前線程中有無session，如果沒有，調用sessionFactory.openSession()產生新的session，
并放入到當前線程中。如果session存在，直接取當前線程中的session，當使用此方法產生的session時，
crud操作必須在事務中進行，并且不用關閉session。
jdbc的缺點：
1.代碼太繁瑣，2、不是面向對象的數據庫操作。
3、資源關閉的代碼繁瑣，每次都需要打開和關閉。
4、沒有數據緩存。5、數據庫移植性差。
優點：是最底層的操作，所以效率高。
hibernate優點：
1、代碼精簡、2、是面向對象的數據庫操作
3.只需要關閉一個session對象就可以了
4.數據有緩存，一級緩存和二級緩存用于查詢緩存
5.都是面向對象操作，數據庫移植性好。
缺點：1、程序無法控制sql的生成，如果系統重視對sql優化，不適合用hibernate。
2、如果單表數據量超過一千萬，不適合用hibernate
前端傳遞json數據，配置第一種方法
<!-- media type -->
<dependency>
<groupId>org.glassfish.jersey.media</groupId>
<artifactId>jersey-media-moxy</artifactId>
<version>${jersey.version}</version>
</dependency>
@ApplicationPath("/webapi/*")
public class AirResourceConfig extends ResourceConfig {
public AirResourceConfig() {
// packages("com.example.resource");
register(BookResource.class);
}
}
前端傳遞json數據，配置第二種方法
<!-- media type -->
<dependency>
<groupId>org.glassfish.jersey.media</groupId>
<artifactId>jersey-media-json-jackson</artifactId>
<version>${jersey.version}</version>
</dependency>
@ApplicationPath("/api/*")
public class JsonResourceConfig extends ResourceConfig {
public JsonResourceConfig() {
register(BookResource.class);
register(JacksonFeature.class);
register(JsonContextProvider.class);
}
}
@Provider
public class JsonContextProvider implements ContextResolver<ObjectMapper> {
final ObjectMapper d;
final ObjectMapper c;
public JsonContextProvider() {
d = createDefaultMapper();
c = createCombinedMapper();
}
private static ObjectMapper createCombinedMapper() {
Pair ps = createIntrospector();
ObjectMapper result = new ObjectMapper();
//result.configure(Feature.WRAP_ROOT_VALUE, true);
//result.configure(DeserializationConfig.Feature.UNWRAP_ROOT_VALUE, true);
result.setDeserializationConfig(result.getDeserializationConfig().withAnnotationIntrospector(ps));
result.setSerializationConfig(result.getSerializationConfig().withAnnotationIntrospector(ps));
return result;
}
private static ObjectMapper createDefaultMapper() {
ObjectMapper result = new ObjectMapper();
result.configure(Feature.INDENT_OUTPUT, true);
return result;
}
private static Pair createIntrospector() {
AnnotationIntrospector p = new JacksonAnnotationIntrospector();
AnnotationIntrospector s = new JaxbAnnotationIntrospector();
return new Pair(p, s);
}
@Override
public ObjectMapper getContext(Class<?> type) {
if (type == JsonHybridBook.class) {
return c;
} else {
return d;
}
}
}
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {
private static Iterator<String> iterator;
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
iterator = list.iterator();
while (iterator.hasNext()) {
String next = iterator.next();
if("1".equals(next)){
list.remove(next);
}
}
for(String s : list){
System.out.println(s);
}
}
}