java學習
          

          java學習
          

           
          
			
          
				
					


          
	
			  

          


		
          
			
          Java的方法的泛型
          
			
			
          package com;
          import java.util.List;
          public class App<T> {
          	/**
          	 * list必須都是Number的子類
          	 * @param list
          	 */
          	public void get1(List<? extends Number>  list){
          		System.out.println(list.size());
          	}
          	/**
          	 * list必須都是String的父類
          	 * @param list
          	 */
          	public void get2(List<? super String>  list){
          		System.out.println(list.size());
          	}
          }
          
			
			
          		
				posted @ 2017-11-10 16:46 楊軍威 閱讀(113) | 評論 (0) | 編輯 收藏
			
          
		
          
	
		
          
			
          秒殺系統架構優化思路
          
			
			     摘要: 一、秒殺業務為什么難做1）im系統，例如qq或者微博，每個人都讀自己的數據（好友列表、群列表、個人信息）；2）微博系統，每個人讀你關注的人的數據，一個人讀多個人的數據；3）秒殺系統，庫存只有一份，所有人會在集中的時間讀和寫這些數據，非常多個人同時讀一個數據。 例如：小米手機每周二的秒殺，可能手機只有1萬部，但瞬時進入的流量可能是幾百幾千萬。又例如：12306搶票，票是有限的，庫存一份，瞬...  閱讀全文
			
			
          		
				posted @ 2017-11-06 17:35 楊軍威 閱讀(184) | 評論 (0) | 編輯 收藏
			
          
		
          
	
		
          
			
          設計模式之jdk的動態代理
          
			
			jdk的動態代理對象和目標對象要實現同一個接口。
          public class Classes implements Serializable{
          	private Long cid;
          	public Long getCid() {
          		return cid;
          	}
          	public void setCid(Long cid) {
          		this.cid = cid;
          	}
          	public String getCname() {
          		return cname;
          	}
          	public void setCname(String cname) {
          		this.cname = cname;
          	}
          	public String getDescription() {
          		return description;
          	}
          	public void setDescription(String description) {
          		this.description = description;
          	}
          	
          	private String cname;
          	private String description;
          }
          public interface ClassesDao {
          	public void saveClasses(Classes classes);
          }
          public class ClassesDaoImpl implements ClassesDao{
          	@Override
          	public void saveClasses(Classes classes) {
          		System.out.println("保存");
          	}
          }
          public class MyTransaction {
          	public void beginTransaction(){
          	System.out.println("開始事務");
          	}
          	public void commit(){
          		System.out.println("提交事務");
          	}
          }
          public class ClassesDaoInterceptor implements InvocationHandler{
          	private Object target;
          	private MyTransaction myTransaction;
          	public ClassesDaoInterceptor(Object target,MyTransaction myTransaction){
          		this.target = target;
          		this.myTransaction = myTransaction;
          	}
          	@Override
          	public Object invoke(Object proxy, Method method, Object[] args)
          			throws Throwable {
          		System.out.println(proxy.getClass().getName());
          		if(method.getName().equals("saveClasses")||
          				method.getName().equals("updateClasses")){
          			this.myTransaction.beginTransaction();//??
          			method.invoke(this.target, args);//?????
          			this.myTransaction.commit();
          		}else{
          			method.invoke(this.target, args);
          		}
          		return null;
          	}
          }
          public class ClassesDaoTest {
          	public static void testSaveClasses(){
          		Object target = new ClassesDaoImpl();
          		MyTransaction myTransaction = new MyTransaction();
          		ClassesDaoInterceptor interceptor = new ClassesDaoInterceptor(target, myTransaction);		
          		ClassesDao proxyDao = (ClassesDao) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), interceptor);
          		Classes classes = new Classes();
          		classes.setCname("aaaa");
          		proxyDao.saveClasses(classes);
          	}
          	public static void main(String[] args) {
          		testSaveClasses();
          	}
          }
          spring的事務也是動態代理實現的，當一個服務類里的一個實現了服務接口的方法中調用另一個服務方法，第二個服務方法不會加入到事務中，因為這種調用方式不是被代理對象調用，而是實際目標對象調用，不會產生代理對象，所以第二個服務方法不會加入到事務中，如果想實現這種操作，需要先得到aop的代理對象，AopContext.currentProxy();，得到服務接口，進行調用服務方法。spring的事務代理是cglib實現的，只能代理訪問接口中的方法。
          
			
			
          		
				posted @ 2017-09-14 15:49 楊軍威 閱讀(137) | 評論 (0) | 編輯 收藏
			
          
		
          
	
		
          
			
          設計模式之cglib的動態代理
          
			
			cglib的動態生成的代理對象是目標類的子類。
          public class Classes implements Serializable{
          	private Long cid;
          	public Long getCid() {
          		return cid;
          	}
          	public void setCid(Long cid) {
          		this.cid = cid;
          	}
          	public String getCname() {
          		return cname;
          	}
          	public void setCname(String cname) {
          		this.cname = cname;
          	}
          	public String getDescription() {
          		return description;
          	}
          	public void setDescription(String description) {
          		this.description = description;
          	}
          	
          	private String cname;
          	private String description;
          }
          public interface ClassesDao {
          	public void saveClasses(Classes classes);
          }
          public class ClassesDaoImpl implements ClassesDao{
          	@Override
          	public void saveClasses(Classes classes) {
          		System.out.println("保存");
          	}
          }
          public class ClassesDaoInterceptor implements MethodInterceptor {
          	private Object target;
          	private MyTransaction myTransaction;
          	public ClassesDaoInterceptor(Object target, MyTransaction myTransaction) {
          		this.target = target;
          		this.myTransaction = myTransaction;
          	}
          	public Object create() {
          		Enhancer en = new Enhancer();
          		en.setSuperclass(target.getClass());
          		en.setCallback(this);
          		return en.create();
          	}
          	@Override
          	public Object intercept(Object proxy, Method method, Object[] args,
          			MethodProxy arg3) throws Throwable {
          		System.out.println(proxy.getClass().getName());
          		System.out.println(arg3.getSuperName());
          		if (method.getName().equals("saveClasses")
          				|| method.getName().equals("updateClasses")) {
          			this.myTransaction.beginTransaction();// ??
          			method.invoke(this.target, args);// ?????
          			this.myTransaction.commit();
          		} else {
          			method.invoke(this.target, args);
          		}
          		return null;
          	}
          }
          public class MyTransaction {
          	public void beginTransaction(){
          	System.out.println("開始事務");
          	}
          	public void commit(){
          		System.out.println("提交事務");
          	}
          }
          public class ClassesDaoTest {
          	public static void testSaveClasses(){
          		Object dao = new ClassesDaoImpl();
          		MyTransaction myTransaction = new MyTransaction();
          		ClassesDaoInterceptor interceptor = new ClassesDaoInterceptor(dao, myTransaction);		
          		ClassesDaoImpl proxyDao= (ClassesDaoImpl) interceptor.create();
          		Classes classes = new Classes();
          		classes.setCname("aaaa");
          		proxyDao.saveClasses(classes);
          	}
          	public static void main(String[] args) {
          		testSaveClasses();
          	}
          }
          
			
			
          		
				posted @ 2017-09-14 15:41 楊軍威 閱讀(132) | 評論 (0) | 編輯 收藏
			
          
		
          
	
		
          
			
          設計模式之模擬jdk的動態代理
          
			
			jdk的動態代理模式的目標類和動態生成的代理類都要實現同一個接口。
          public interface MoveAble {
          void move();
          }
          public interface InvocationHandler {
          	public void invoke(Object o, Method m);
          }
          public class Tank1 implements MoveAble{
          	@Override
          	public void move() {
          		System.out.println("moving");
          	}
          }
          public class TimeHandler implements InvocationHandler{
          	private Object target;
          	public TimeHandler(Object target) {
          		super();
          		this.target = target;
          	}
          	@Override
          	public void invoke(Object o, Method m) {
          		long start = System.currentTimeMillis();
          		System.out.println("starttime:" + start);
          		System.out.println(o.getClass().getName());
          		try {
          			m.invoke(target);
          		} catch (Exception e) {
          			e.printStackTrace();
          		}
          		long end = System.currentTimeMillis();
          		System.out.println("time:" + (end-start));
          	}
          }
          public class Proxy {
          	public static Object newProxyInstance(Class infce, InvocationHandler invocationHandler) throws Exception { //JDK6 Complier API, CGLib, ASM
          		String methodStr = "";
          		String rt = "\r\n";
          		Method[] methods = infce.getMethods();
          		for(Method m : methods) {
          			Class<?> returnType = m.getReturnType();
          			methodStr += "@Override" + rt + 
          						 "public  "+returnType+" " + m.getName() + "() {" + rt +
          						 "    try {" + rt +
          						 "    Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
          						 "    h.invoke(this, md);" + rt +
          						 "    }catch(Exception e) {e.printStackTrace();}" + rt +
          						
          						 "}";
          		}
          		String src = 
          			"package proxy.tank;" +  rt +
          			"import java.lang.reflect.Method;" + rt +
          			"public class $Proxy1 implements " + infce.getName() + "{" + rt +
          			"    public $Proxy1(InvocationHandler h) {" + rt +
          			"        this.h = h;" + rt +
          			"    }" + rt +
          			"    proxy.tank.InvocationHandler h;" + rt +
          			methodStr +
          			"}";
          		String fileName = 
          			"d:/src/proxy/tank/$Proxy1.java";
          		File f = new File(fileName);
          		FileWriter fw = new FileWriter(f);
          		fw.write(src);
          		fw.flush();
          		fw.close();
          		//compile
          		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
          		StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
          		Iterable units = fileMgr.getJavaFileObjects(fileName);
          		CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
          		t.call();
          		fileMgr.close();
          		
          		//load into memory and create an instance
          		URL[] urls = new URL[] {new URL("file:/" + "d:/src/")};
          		URLClassLoader ul = new URLClassLoader(urls);
          		Class c = ul.loadClass("proxy.tank.$Proxy1");
          		System.out.println(c);
          		
          		Constructor ctr = c.getConstructor(InvocationHandler.class);
          		Object m = ctr.newInstance(invocationHandler);
          		return m;
          	}
          }
          public class Client {
          	public static void main(String[] args) throws Exception {
          		Tank1 t = new Tank1();
          		InvocationHandler h = new TimeHandler(t);
          		MoveAble m = (MoveAble)Proxy.newProxyInstance(MoveAble.class, h);
          		m.move();
          	}
          }
          
			
			
          		
				posted @ 2017-09-14 15:35 楊軍威 閱讀(129) | 評論 (0) | 編輯 收藏
			
          
		
          
	
		
          
			
          設計模式之靜態代理
          
			
			
          public interface MoveAble {
          void move();
          }
          public class Tank1 implements MoveAble{
          	@Override
          	public void move() {
          		System.out.println("moving");
          	}
          }
          /**
           * 
           * 聚合
           *
           */
          public class TankTime3 implements MoveAble{
          	private MoveAble t;
          	public TankTime3(){}
          	public TankTime3(MoveAble t){
          		this.t=t;
          	}
          	@Override
          	public void move() {
          	long s = System.currentTimeMillis();
          		t.move();
          		long e = System.currentTimeMillis();
          		System.out.println(e-s);
          	}
          }
          public class Test {
          public static void main(String[] args) {
          	Tank1 t =new Tank1();
          	TankTime3 tt = new TankTime3(t);
          	tt.move();
          }
          }
          
			
			
          		
				posted @ 2017-09-14 15:27 楊軍威 閱讀(138) | 評論 (0) | 編輯 收藏
			
          
		
          
	
		
          
			
          設計模式之策略模式
          
			
			使用策略模式自定義對象排序和比較屬性值排序的例子
          /**
           * 
           * 實體類的接口
           *
           */
          public interface DongWu {
          	public int getAge();
          	public void setAge(int age) ;
          	public int getHigh();
          	public void setHigh(int high) ;
          }
          /**
           * 
           * 排序接口
           *
           */
          public interface MyComparator  {
          	int comparatorTo(Object object);
          }
          /**
           * 
           * 具體的排序接口，和具體的實體類對象無關
           *
           */
          public interface TypeComparator  {
          	int comparatorTo(Object object1,Object object2);
          }
          /**
           * 
           * 按照年紀倒敘排序
           *
           */
          public class AgeDescTypeComparator implements TypeComparator {
          	@Override
          	public int comparatorTo(Object object1, Object object2) {
          		DongWu c1 = (DongWu) object1;
          		DongWu dw = (DongWu) object2;
          		if (c1.getAge() > dw.getAge()) {
          			return -1;
          		} else if (c1.getAge() < dw.getAge()) {
          			return 1;
          		}
          		return 0;
          	}
          }
          /**
           * 
           * 按照年紀正敘排序
           *
           */
          public class AgeTypeComparator implements TypeComparator {
          	@Override
          	public int comparatorTo(Object object1, Object object2) {
          		DongWu c1 = (DongWu) object1;
          		DongWu dw = (DongWu) object2;
          		if (c1.getAge() > dw.getAge()) {
          			return 1;
          		} else if (c1.getAge() < dw.getAge()) {
          			return -1;
          		}
          		return 0;
          	}
          }
          public class Cat implements MyComparator,DongWu{
          	private int age;
          	private int high;
          	private TypeComparator typeComparator =new AgeDescTypeComparator();
          	public Cat(){}
          	public Cat(int age){
          		this.age=age;
          	}
          	public int getAge() {
          		return age;
          	}
          	public void setAge(int age) {
          		this.age = age;
          	}
          	public int getHigh() {
          		return high;
          	}
          	public void setHigh(int high) {
          		this.high = high;
          	}
          	@Override
          	public int comparatorTo(Object object) {
          		DongWu cat = (DongWu) object;
          		return typeComparator.comparatorTo(this, cat);
          		
          	}
          	
          }
          public class Dog implements MyComparator,DongWu{
          	private int age;
          	private int high;
          	private TypeComparator typeComparator =new AgeDescTypeComparator();
          	public Dog(){}
          	public Dog(int age){
          		this.age=age;
          	}
          	public int getAge() {
          		return age;
          	}
          	public void setAge(int age) {
          		this.age = age;
          	}
          	public int getHigh() {
          		return high;
          	}
          	public void setHigh(int high) {
          		this.high = high;
          	}
          	@Override
          	public int comparatorTo(Object object) {
          		DongWu d = (DongWu) object;
          		return typeComparator.comparatorTo(this, d);
          		
          	}
          	
          }
          public class DataSorter {
          	public static void sort(MyComparator[] arr){
          		for (int i = arr.length; i >0 ; i--) {
          			for(int j=0;j<i-1;j++){
          				MyComparator m1=arr[j];
          				MyComparator m2= arr[j+1];
          				if(m1.comparatorTo(m2)==1){
          					swap(arr,j,j+1);
          				}
          			}
          		}
          	}
          	private static void swap(Object[] arr, int j, int i) {
          		Object temp =arr[j];
          		arr[j]=arr[j+1];
          		arr[j+1]=temp;
          		
          	}
          }
          
			
			
          		
				posted @ 2017-09-13 11:06 楊軍威 閱讀(114) | 評論 (0) | 編輯 收藏
			
          
		
          
	
		
          
			
          設計模式之Iterator
          
			
			
          public interface Iterator {
          	Object next();
          	boolean hasNext();
          }
          public interface Collection {
          	void add(Object data);
          	int size();
          	Iterator iterator();
          }
          //集合
          public class MyArrayList implements Collection{
          	private Object[] array = new Object[10];
          	private int index=0;//數值當前可以放值的下標
          	public void add( Object obj){
          		if(index==array.length){
          			Object[] newArray = new Object[array.length*2];
          			System.arraycopy(array, 0, newArray, 0, index);
          			array=newArray;
          		}
          		array[index]=obj;
          		index++;
          	}
          	public int size(){
          		return index;
          	}
          	@Override
          	public Iterator iterator() {
          		return new Aaa();
          	}
          	private class Aaa implements Iterator{
          		private int c=0;
          		@Override
          		public boolean hasNext() {
          			if(c<index){
          				return true;
          			}else{
          				return false;
          			}
          		
          		}
          		@Override
          		public Object next() {
          			 Object object = array[c];
          			 c++;
          			return object;
          		}
          		
          	}
          	public static void main(String[] args) {
          		MyArrayList arr = new MyArrayList();
          		for (int i = 0; i < 20; i++) {
          			arr.add(new Object());
          		}
          		System.out.println(arr.size());
          		Iterator iterator = arr.iterator();
          		while(iterator.hasNext()){
          			System.out.println(iterator.next());
          		}
          	}
          	
          }
          //鏈表
          public class MyNode {
          	private Object data;
          	private MyNode nextNode;
          	public MyNode(Object data,MyNode nextNode){
          		this.data=data;
          		this.nextNode=nextNode;
          	}
          	public Object getData() {
          		return data;
          	}
          	public void setData(Object data) {
          		this.data = data;
          	}
          	public MyNode getNextNode() {
          		return nextNode;
          	}
          	public void setNextNode(MyNode nextNode) {
          		this.nextNode = nextNode;
          	}
          	
          }
          public class MyLinkTable implements Collection{
          	private MyNode head;
          	private MyNode tail;
          	private int size = 0;
          	public void add(Object data) {
          		MyNode n = new MyNode(data, null);
          		if (head == null) {
          			head = n;
          			tail = n;
          		}
          		tail.setNextNode(n);
          		tail = n;
          		size++;
          	}
          	public int size() {
          		return size;
          	}
          	
          	public MyNode getHead() {
          		return head;
          	}
          	public void setHead(MyNode head) {
          		this.head = head;
          	}
          	public MyNode getTail() {
          		return tail;
          	}
          	public void setTail(MyNode tail) {
          		this.tail = tail;
          	}
          	@Override
          	public Iterator iterator() {
          		return new Aaa();
          	}
          	private class Aaa implements Iterator{
          		private int c=0;
          		MyNode node=null;
          		@Override
          		public boolean hasNext() {
          		
          			for (int i = 0; i <=c; i++) {
          				if(i==0){
          					node = head;
          				}else{
          					node = node.getNextNode();
          				}
          				
          			}
          			if(node==null){
          				return false;
          			}else{
          				return true;
          			}
          		}
          		@Override
          		public Object next() {
          			for (int i = 0; i <=c; i++) {
          				if(i==0){
          					node = head;
          				}else{
          					node = node.getNextNode();
          				}
          			}
          			c++;
          			return node;
          		}
          		
          	}
          	public static void main(String[] args) {
          		MyLinkTable node = new MyLinkTable();
          		node.add(1);
          		node.add(2);
          		node.add(3);
          	Iterator iterator = node.iterator();
          	while(iterator.hasNext()){
          		MyNode node1=	(MyNode) iterator.next();
          		System.out.println(node1.getData());
          	}
          	}
          	
          }
          
			
			
          		
				posted @ 2017-09-12 15:54 楊軍威 閱讀(116) | 評論 (0) | 編輯 收藏
			
          
		
          
	
		
          
			
          設計模式之裝飾者模式
          
			
			裝飾模式指的是在不必改變原類文件和使用繼承的情況下，動態地擴展一個對象的功能。它是通過創建一個包裝對象，也就是裝飾來包裹真實的對象。
          public interface ICake {
          	public float cost();
          }
          public abstract class CakeDecorator implements ICake{
          }
          public class MilkCake implements ICake{
          	@Override
          	public float cost() {
          		return 100f;
          	}
          }
          public class Berry extends CakeDecorator {
          	private ICake cake;
          	public Berry(ICake cake) {
          		this.cake = cake;
          	}
          	
          	@Override
          	public float cost() {
          		float berryPrice = 5f;
          		return cake.cost() + berryPrice;
          	}
          }
          public class Chocolate extends CakeDecorator{
          	private ICake cake;
          	
          	public Chocolate(ICake cake) {
          		this.cake = cake;
          	}
          	
          	@Override
          	public float cost() {
          		float chocolatePrice = 25f;
          		return cake.cost() + chocolatePrice;
          	}
          }
          public class Test {
          	public static void main(String[] args) throws FileNotFoundException {
          		
          		MilkCake mc = new MilkCake();
          		Berry b = new Berry(mc);
          		Chocolate c = new Chocolate(b);
          		System.out.println("" + c.cost());
          		
          	
          		
          	}
          }
          
			
			
          		
				posted @ 2017-09-08 10:36 楊軍威 閱讀(105) | 評論 (0) | 編輯 收藏
			
          
		
          
	
		
          
			
          設計模式之觀察者模式
          
			
			觀察者模式（有時又被稱為發布（publish ）-訂閱（Subscribe）模式、模型-視圖（View）模式、源-收聽者(Listener)模式或從屬者模式）是軟件設計模式的一種。在此種模式中，一個目標物件管理所有相依于它的觀察者物件，并且在它本身的狀態改變時主動發出通知。這通常透過呼叫各觀察者所提供的方法來實現。此種模式通常被用來實現事件處理系統。
          public interface Observer {
          	public void update(int low,int heigh,String weather);
          	void removeSubject();
          }
          public interface Subject {
          	public void registerObserver(Observer observer);
          	public void removeObserver(Observer observer);
          	public void notifyObserver();
          	
          }
          public class Android implements Observer{
          	public Android(){}
          	
          	private Subject subject;
          	
          	public Android(Subject subject) {
          		this.subject = subject;
          		this.subject.registerObserver(this);
          	}
          	
          	@Override
          	public void update(int low, int heigh, String weather) {
          		System.out.println("Android" + low + "," + heigh + "," + weather);
          	}
          	
          	public void removeSubject() {
          		subject.removeObserver(this);
          	}
          }
          public class IPad implements Observer{
          	private Subject subject;
          	public IPad(){}
          	public IPad(Subject subject) {
          		this.subject = subject;
          		subject.registerObserver(this);
          	}
          	
          	
          	
          	@Override
          	public void update(int low, int heigh, String weather) {
          		System.out.println("IPad " + low + "," + heigh + "," + weather);
          	}
          	
          	public void removeSubject() {
          		subject.removeObserver(this);
          	}
          }
          public class WeatherData implements Subject{
          	private int low;
          	private int heigh;
          	private String weather;
          	private List<Observer> observerList = new ArrayList<Observer>();
          	
          	public void setData(int low,int heigh,String weather) {
          		this.low = low;
          		this.heigh = heigh;
          		this.weather = weather;
          		notifyObserver();
          	}
          	
          	
          	
          	public int getLow() {
          		return low;
          	}
          	public int getHeigh() {
          		return heigh;
          	}
          	public String getWeather() {
          		return weather;
          	}
          	@Override
          	public void registerObserver(Observer observer) {
          		if(!observerList.contains(observer)) {
          			observerList.add(observer);
          		}
          	}
          	@Override
          	public void removeObserver(Observer observer) {
          		if(observerList.contains(observer)) {
          			observerList.remove(observer);
          		}
          	}
          	@Override
          	public void notifyObserver() {
          		for(Observer o : observerList) {
          			o.update(getLow(), getHeigh(), getWeather());
          		}
          	}
          	
          	
          }
          public class Test {
          	public static void main(String[] args) {
          		
          		
          		WeatherData wd = new WeatherData();
          		
          		Android android = new Android(wd);
          		//android.removeSubject();
          	
          		IPad ipad = new IPad(wd);
          		//ipad.removeSubject();
          		
          		wd.setData(2, 23, "---");
          	}
          }
          
			
			
          		
				posted @ 2017-09-08 10:09 楊軍威 閱讀(140) | 評論 (0) | 編輯 收藏
			
          
		
          
	
          僅列出標題
          
	共43頁: First 上一頁 5 6 7 8 9 10 11 12 13 下一頁 Last 

          


				
			
          
			
          
				
					

          導航
          

					

          統計
          
	
					
					

          常用鏈接
          


          留言簿
          


		
          隨筆檔案
          
		
				
			
	



          搜索
          



          最新評論
	
          



          閱讀排行榜
          



          評論排行榜
          


				
			
          			
			

	

    
          
        
	




主站蜘蛛池模板：
柘荣县|
鸡西市|
牡丹江市|
开鲁县|
林西县|
汪清县|
关岭|
五常市|
海伦市|
平泉县|
如东县|
从江县|
仲巴县|
绵竹市|
潜江市|
浪卡子县|
扎赉特旗|
义乌市|
海门市|
辽宁省|
沙湾县|
南丰县|
隆德县|
长泰县|
新民市|
黔江区|
连城县|
石阡县|
平度市|
波密县|
陈巴尔虎旗|
工布江达县|
婺源县|
广元市|
贡嘎县|
陕西省|
晋宁县|
中江县|
自贡市|
岳阳市|
美姑县|