Problem einem Zaehler in mein Java - Code

  • Problem einem Zaehler in mein Java - Code

    Hallo zusammen,
    ich muss ein Programm schreiben , das zählt wie oft jede Webseite aus unserem Server aufgerufen wird, und das Ergebnis in eine MySQL – Datenbank speichert . Ich habe in der Klasse SessionObject 2 Variablen erzeugt,die die aufgerufene Webseite und die dazugehörige Session-ID speichert , eine Klasse SessionArray die alle aufgerufene Seiten und Session-ID in einem Puffer(Array) anlegt, und die Daten in die Datenbank über einen Thread schreibt . In der Klasse LiveStatReceiver wird eine Instanz der Klasse SessionArray erzeugt,die Variable pagecounter sollte angeben wie oft ein Element im Array vorhanden ist.Wenn z.B die aufgerufene Webseite www.bucho.de schon 5 Male aufgerufen wurde,sollte pagecounter den Wert 5 haben,leider gibt pagecounter immer den Wert 0, und ich verstehe nicht warum. Die Datenbankzugriffe werden über Jdbc-Template vom Spring durchgeführt.
    Hier ist mein Code,bei Rückfragen stehe ich natürlich zur Verfügung.
    Im Voraus vielen Dank.

    Quellcode

    1. import javax.servlet.*;
    2. import javax.servlet.http.*;
    3. import java.io.IOException;
    4. import org.apache.commons.logging.Log;
    5. import org.apache.commons.logging.LogFactory;
    6. import org.springframework.context.ApplicationContext;
    7. import org.springframework.web.context.support.WebApplicationContextUtils;
    8. import org.springframework.jdbc.datasource.*;
    10. public class LiveStatReceiver implements Filter{
    12. protected final Log log = LogFactory.getLog(getClass());
    13. protected FilterConfig config;
    14. //aktuelle Groesse des Arrays
    15. private int counter = 0;
    16. // zählt wie oft ein Object im Array vorhanden ist
    17. private int pagecounter = 0;
    18. /*maximale Groesse des Arrays*/
    19. private static final int MAX = 1000;
    20. /* Array zur Speicherung aufgerufenen Webseiten und deren Session IDs */
    21. private static SessionObject[] objectArray = new SessionObject[MAX];
    22. /*speichert die aktuelle Webseite*/
    23. String page = "";
    24. /*speichert die Session ID*/
    25. String sessionID = "";
    26. /*fuer die Datasourcen*/
    27. DriverManagerDataSource dataSource = new DriverManagerDataSource(); private SessionArray sessionArray;
    29. public SessionArray getSessionArray(){
    30. if (sessionArray == null){
    31. sessionArray = new SessionArray(counter,pagecounter,objectArray,dataSource);
    32. }
    33. return sessionArray;
    34. }
    35. public FilterConfig getConfig() {
    36. return config;
    37. }
    38. public void setConfig(FilterConfig config) {
    39. this.config = config;
    40. }
    41. public void init(FilterConfig config) throws ServletException{
    42. this.config = config;
    43. log.info("-----LiveStatReceiver : init ---> Filtername : " + config.getFilterName());
    45. ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(config.getServletContext());
    46. dataSource = (DriverManagerDataSource)ctx.getBean("myDataSource");
    47. }
    49. @SuppressWarnings("static-access")
    50. public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain)
    51. throws ServletException,IOException,NullPointerException{
    53. HttpServletRequest req = (HttpServletRequest)request;
    54. page = req.getRequestURI();
    55. HttpSession session = req.getSession();
    56. sessionID = (String)session.getId();
    57. if((page != null && !page.equals("")) && (sessionID != null &&
    58. !sessionID.equals(""))){
    59. try{
    60. /*Erzeugung einer Instanz von SessionObject,das Object sessionObject wird spaeter im Array objectArray angelegt.*/
    61. SessionObject sessionObject = new SessionObject(page,sessionID);
    62. if(sessionObject != null){
    63. /*wenn counter null ist,bedeutet dass,die aufgerufene Seite noch nicht im Array angelegt ist,das Array ist noch leer,dann pagecounter ist auch null.*/
    64. if(counter < 1){
    65. pagecounter = 0;
    66. }else{
    67. for(int i=0; i<counter; i++){
    68. if(objectArray[i].getPage() == page && objectArray[i].getSessionID()==sessionID){
    69. /*pagecounter sollte sich inkrementieren sobald das Array objectArray nicht mehr leer,was leider hier nicht der Fall ist.Beim Testen hat pagecounter immer den Wert null*/
    70. pagecounter++; }
    71. }
    72. }
    73. /*hier wird ein neus Object im Array angelegt*/
    74. SessionObject newObject;
    75. newObject = sessionObject;
    76. objectArray[counter] = newObject;
    77. // counter inkrementiert sich
    78. counter++;
    79. getSessionArray().setCounter(counter);
    80. getSessionArray().setPagecounter(pagecounter);
    81. getSessionArray().setSessionObject(objectArray);
    82. }
    83. }catch(NullPointerException e){
    84. System.out.println("NullPointerException : "+e.getMessage());
    85. }
    86. }
    87. try {
    88. getSessionArray().doThreadCountdown();
    89. log.info("--- Thread starten.");
    90. }catch (InterruptedException e) {
    91. e.printStackTrace();
    92. for (StackTraceElement trace : new Throwable().getStackTrace() ){
    93. log.info(" STRACK TRACE - ERROR : " + trace);
    94. }
    95. }
    96. chain.doFilter(request,response);
    97. }
    98. public void destroy(){}
    99. }
    101. import java.util.Iterator;
    102. import java.util.List;
    103. import java.util.Map;
    104. import org.apache.commons.logging.Log;
    105. import org.apache.commons.logging.LogFactory;
    106. import org.springframework.jdbc.core.JdbcTemplate;
    107. import org.springframework.jdbc.datasource.DriverManagerDataSource;
    108. public class SessionArray extends Thread{
    109. /*aktuelle Groesse des Arrays*/
    110. private int counter;
    111. /*maximale Groesse des Arrays*/
    112. private static final int MAX = 1000;
    113. /*incrementiert sich falls eine Seite schon aufgerufen wird.*/
    114. private int pagecounter;
    115. /*Puffer zur Speicherung aller aufgerufene Seiten und Session_ID*/
    116. private SessionObject[] sessionObject = new SessionObject[MAX];
    117. protected final Log log = LogFactory.getLog(getClass());
    118. DriverManagerDataSource dataSource ;
    119. //jdbcTemplate fuer den Datenbankzugriff
    120. private JdbcTemplate jdbcTemplate;
    121. public SessionArray(int counter,int pagecounter,SessionObject[] sessionObject,DriverManagerDataSource dataSource){
    122. this.counter = counter;
    123. this.pagecounter = pagecounter;
    124. this.sessionObject = sessionObject;
    125. this.dataSource = dataSource;
    126. }
    127. public void run(){
    128. try{
    129. jdbcTemplate = new JdbcTemplate(dataSource);
    130. String stringCounter = "";
    131. String stringSessionCounter ="";
    132. /*wählt in dem Puffer die letzte aufgerufene Seite,und ermittelt ob sie schon in der Tabelle existiert*/
    133. List list = jdbcTemplate.queryForList("select page,counter,sessioncounter from statistik where page =?",new Object[] {sessionObject[counter-1].getPage()});
    134. log.info("######## SessionArray run --> List-Size : "+list.size());
    135. Iterator it = list.iterator();
    136. /*Ergebnis der Datenbankabfrage.*/
    137. while(it.hasNext()) {
    138. Map userMap = (Map) it.next();
    139. /*Umwandlung counter in String*/
    140. stringCounter = userMap.get("counter").toString();
    141. /*Umwandlung sessioncounter in String*/
    142. stringSessionCounter =userMap.get("sessioncounter").toString();
    143. }
    144. int newCounter = 1;
    145. int newSessionCounter = 1;
    146. /*falls die aufgerufene Seite noch nicht in der Tabelle vorhanden ist,wird sie eingetragen*/
    147. if(list.size() == 0){
    148. jdbcTemplate.update("insert into statistik (page,counter,sessioncounter)" +
    149. " values (?,?,?)",new Object[]{sessionObject[counter-1].getPage(),newCounter,newSessionCounter});
    150. }else{
    151. /*falls die Seite schon existiert,wird ein Update der Tabelle durchgeführt,was hier leider nicht funktioniert.*/
    152. newCounter = Integer.parseInt(stringCounter)+1 ;
    153. if(pagecounter == 0){
    154. log.info("pagecounter: " + pagecounter);
    156. newSessionCounter = Integer.parseInt(stringSessionCounter) + 1;
    157. }else{
    158. newSessionCounter = Integer.parseInt(stringSessionCounter);
    159. }
    160. jdbcTemplate.update("update statistik set page = ?,counter = ?," +
    161. "sessioncounter =? where page = ?",new Object[] {sessionObject[counter-1].getPage(),newCounter,
    162. newSessionCounter,sessionObject[counter-1].getPage()});
    163. }
    164. }catch(Exception e){
    165. log.info("ERROR :" + e.getCause());
    166. for (StackTraceElement trace : new Throwable().getStackTrace() ){
    167. log.info("STRACK TRACE - ERROR : " + trace);
    168. }
    169. }
    170. }
    171. public void doThreadCountdown() throws java.lang.InterruptedException {
    172. try {
    173. Thread.sleep(2);
    174. } catch(InterruptedException e) {
    175. log.info("Thread interrupted!");
    176. }
    177. new SessionArray(counter,pagecounter,sessionObject,dataSource).start();
    178. }
    179. public int getPagecounter() {
    180. return pagecounter;
    181. }
    182. public void setPagecounter(int pagecounter) {
    183. this.pagecounter = pagecounter;
    184. }
    185. public int getCounter() {
    186. return counter;
    187. }
    188. public void setCounter(int counter) {
    189. this.counter = counter;
    190. }
    191. public SessionObject[] getSessionObject() {
    192. return sessionObject;
    193. }
    194. public void setSessionObject(SessionObject[] sessionObject) {
    195. this.sessionObject = sessionObject;
    196. }
    197. }
    199. public class SessionObject {
    200. String page;
    201. String sessionID;
    202. public SessionObject(String myPage,String sessionID){
    203. setPage(myPage);
    204. setSessionID(sessionID);
    205. }
    206. public String getSessionID() {
    207. return sessionID;
    208. }
    209. public void setSessionID(String sessionID) {
    210. this.sessionID = sessionID;
    211. }
    212. public String getPage() {
    213. return page;
    214. }
    215. public void setPage(String page) {
    216. this.page = page;
    217. }
    218. }
    223. CREATE TABLE `statistik` (
    224. `id` int(10) NOT NULL auto_increment,
    225. `page` varchar(250) NOT NULL,
    226. `counter` int(10) NOT NULL,
    227. `sessioncounter` varchar(250) NOT NULL,
    228. PRIMARY KEY (`id`)
    229. ) TYPE=MyISAM AUTO_INCREMENT=1;
    232. <?xml version="1.0" encoding="ISO-8859-1"?>
    233. <web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    234. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    235. xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    236. http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
    237. <display-name>Test für das Statistik-Projekt</display-name>
    238. <context-param>
    239. <param-name>contextConfigLocation</param-name>
    240. <param-value>/WEB-INF/applicationContext-jdbc.xml</param-value>
    241. </context-param>
    242. <listener>
    243. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    244. </listener>
    245. <servlet>
    246. <servlet-name>action</servlet-name>
    247. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    248. <load-on-startup>1</load-on-startup>
    249. </servlet>
    250. <servlet-mapping>
    251. <servlet-name>action</servlet-name>
    252. <url-pattern>*.html</url-pattern>
    253. </servlet-mapping>
    254. <jsp-config>
    255. <jsp-property-group>
    256. <url-pattern>*.jsp</url-pattern>
    257. <scripting-invalid>false</scripting-invalid>
    258. <!-- <el-ignored>false</el-ignored>-->
    259. </jsp-property-group>
    260. <taglib>
    261. <taglib-uri>http://www.springframework.org/tags</taglib-uri>
    262. <taglib-location>/WEB-INF/spring.tld</taglib-location>
    263. </taglib>
    264. </jsp-config>
    265. <servlet>
    266. <description>Added by JBuilder to compile JSPs with debug info</description>
    267. <servlet-name>debugjsp</servlet-name>
    268. <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
    269. <init-param>
    270. <param-name>classdebuginfo</param-name>
    271. <param-value>true</param-value>
    272. </init-param>
    273. <load-on-startup>3</load-on-startup>
    274. </servlet>
    275. <servlet-mapping>
    276. <servlet-name>debugjsp</servlet-name>
    277. <url-pattern>*.jsp</url-pattern>
    278. </servlet-mapping>
    279. <filter>
    280. <filter-name>liveStatReceiver</filter-name>
    281. <filter-class>src.sessionSave.LiveStatReceiver</filter-class>
    282. </filter>
    283. <filter-mapping>
    284. <filter-name>liveStatReceiver</filter-name>
    285. <url-pattern>*.html</url-pattern>
    286. </filter-mapping>
    287. </web-app>
    290. <?xml version="1.0" encoding="UTF-8"?>
    291. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
    292. <beans>
    293. <bean id="myDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    294. <property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property>
    295. <property name="url"><value>jdbc:mysql://localhost/pagecounter</value></property>
    296. <property name="username"><value>root</value></property>
    297. <property name="password"><value></value></property>
    298. </bean>
    299. </beans>
    Alles anzeigen